/**
 * V3版本 - 统一策略配置管理
 * 整合了原有的重量规则页面、策略映射页面、策略区域配置页面
 * 基于V3数据模型，实现策略、区域、重量规则的统一管理
 *
 * @requires api.js - 统一API服务管理
 * @version 3.0.1
 * @since 2025-08-29
 */

// 使用全局API服务（从 api.js 中获取）
// 确保 api.js 已经加载
// const { getGlobalApiInstance, waitForApiInitialization } = window.__ES6_EXPORTS__['./api.js'] || window;

// ==================== API统一管理 ====================
/**
 * 获取统一API实例（升级版）
 * 优先使用统一API服务，不可用时回退到直接fetch
 */
function getV3ApiInstance() {
    try {
        // 方法 1：使用新的全局API获取方法
        const getGlobalApiInstance = window.getGlobalApiInstance || (window.__ES6_EXPORTS__ && window.__ES6_EXPORTS__['./api.js'] ? window.__ES6_EXPORTS__['./api.js'].getGlobalApiInstance : undefined);
        if (getGlobalApiInstance) {
            const apiInstance = getGlobalApiInstance();
            if (apiInstance && typeof apiInstance.request === 'function') {
                console.log('✅ V3使用统一API服务');
                return apiInstance;
            }
        }

        // 方法 2：从全局对象获取
        if (window.FreightAPI && typeof window.FreightAPI.request === 'function') {
            console.log('✅ V3使用全局FreightAPI');
            return window.FreightAPI;
        }

        // 方法 3：兼容性获取
        if (window.getApiInstance && typeof window.getApiInstance === 'function') {
            const instance = window.getApiInstance();
            if (instance) {
                console.log('✅ V3使用兼容API获取方式');
                return instance;
            }
        }

        console.warn('⚠️ 统一API服务不可用，将使用直接fetch调用');
        return null;
    } catch (error) {
        console.warn('⚠️ API实例获取失败:', error);
        return null;
    }
}

/**
 * API路径修复工具
 * 自动为相对路径添加前缀
 */
function fixApiPath(path) {
    if (!path) return path;
    // 已经包含完整基础路径的不需要修复
    if (path.startsWith('/freight/') || path.startsWith('/api/')) return path;
    // 为相对路径添加'/freight/'前缀
    if (path.startsWith('/')) return '/freight' + path;
    return '/freight/' + path;
}

/**
 * 增强fetch调用封装（备用方案）
 * 仅在统一API不可用时使用
 */
async function fetchWithPrefix(url, options = {}) {
    const fixedUrl = fixApiPath(url);
    console.warn(`⚠️ [V3] 使用备用fetch调用: ${url} -> ${fixedUrl}`);
    return window.originalFetch ? window.originalFetch(fixedUrl, options) : fetch(fixedUrl, options);
}

// 覆盖全局fetch函数，自动添加context-path前缀
if (typeof window !== 'undefined' && typeof window.fetch === 'function' && !window.originalFetch) {
    window.originalFetch = window.fetch;
    window.fetch = function (url, options) {
        // 只有相对路径和以'/'开头的路径才需要处理
        if (url && typeof url === 'string' && !url.startsWith('http://') && !url.startsWith('https://')) {
            const fixedUrl = fixApiPath(url);
            if (fixedUrl !== url) {
                console.log(`🔧 全局fetch路径已自动添加context-path: ${url} -> ${fixedUrl}`);
                return window.originalFetch(fixedUrl, options);
            }
        }
        return window.originalFetch(url, options);
    };
}

/**
 * 统一API调用封装（升级版）
 * 优先使用统一API服务，失败时回退到直接fetch
 */
async function unifiedApiCall(apiMethodName, fallbackUrl, requestData = {}, method = 'POST') {
    try {
        // 第一优先级：使用统一API服务
        const apiInstance = getV3ApiInstance();
        if (apiInstance && typeof apiInstance[apiMethodName] === 'function') {
            console.log(`🔧 [V3] 使用统一API: ${apiMethodName}`);
            return await apiInstance[apiMethodName](requestData);
        }

        // 回退方案：直接fetch调用
        console.warn(`⚠️ [V3] API方法 ${apiMethodName} 不可用，使用直接fetch: ${fallbackUrl}`);

        const response = await fetchWithPrefix(fallbackUrl, {
            method: method,
            headers: {'Content-Type': 'application/json;charset=UTF-8'},
            body: method === 'GET' ? undefined : JSON.stringify(requestData)
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const contentType = response.headers.get('content-type');
        if (!contentType || !contentType.includes('application/json')) {
            throw new Error('响应不是JSON格式');
        }

        return await response.json();
    } catch (error) {
        console.error(`API调用失败 [${apiMethodName}]:`, error);
        throw error;
    }
}

/**
 * 初始化API服务连接
 * 确保在模块加载时API服务已可用
 */
async function initializeApiConnection() {
    try {
        console.log('🔄 [V3] 初始化API服务连接...');

        // 等待API初始化完成
        const waitForApiInitialization = window.waitForApiInitialization || (window.__ES6_EXPORTS__ && window.__ES6_EXPORTS__['./api.js'] ? window.__ES6_EXPORTS__['./api.js'].waitForApiInitialization : undefined);
        if (waitForApiInitialization) {
            const apiInstance = await waitForApiInitialization();

            if (apiInstance) {
                console.log('✅ [V3] API服务初始化成功');
                return apiInstance;
            }
        }
        console.warn('⚠️ [V3] API服务初始化失败，将使用备用方案');
        return null;
    } catch (error) {
        console.error('❌ [V3] API服务初始化错误:', error);
        return null;
    }
}

// ========== 问题修复：统一API调用辅助函数 ==========
/**
 * 统一的地区ID查询API调用函数
 * 替代原有的XMLHttpRequest直接调用
 * @param {number} areaId - 地区ID
 * @returns {Promise<Object|null>} - 返回地区信息或null
 */
async function getAreaByIdUnified(areaId) {
    try {
        // 优先使用统一API服务
        const result = await unifiedApiCall(
            'getAreaById',
            '/area/get-by-id',
            {id: parseInt(areaId)}
        );

        if (result.code === 0 && result.data) {
            const area = result.data;
            let displayName = area.name || area.fullName || area.areaName;

            // 根据地区级别构造完整名称
            if (area.level === 3 && area.districtName) {
                displayName = `${area.provinceName || ''}-${area.cityName || ''}-${area.districtName || area.name}`;
            } else if (area.level === 2 && area.cityName) {
                displayName = `${area.provinceName || ''}-${area.cityName || area.name}`;
            } else if (area.level === 1 && area.provinceName) {
                displayName = area.provinceName || area.name;
            }

            console.log('✅ 从统一API获取到地区名称:', displayName);
            return {displayName, area};
        }

        console.warn('⚠️ 统一API返回格式异常:', result);
        return null;
    } catch (error) {
        console.warn('⚠️ 统一API获取地区名称失败:', error);
        return null;
    }
}

// ========== 问题修复结束 ==========

// ==================== 调试：模块加载开始 ====================
console.log('📥 [调试] v3-strategy-config.js 开始加载...');
console.log('📥 [调试] 当前时间:', new Date().toISOString());
console.log('📥 [调试] window对象存在:', !!window);
console.log('📥 [调试] 开始执行IIFE...');

// ================================ V3策略配置管理模块 ================================
window.V3StrategyConfigManager = (function () {
    console.log('🚀 [调试] IIFE开始执行...');
    'use strict';

    console.log('🚀 [调试] 严格模式已启用');

    // 模块内部状态
    let state = {
        // 基础数据
        strategies: [],
        areas: [],
        areaTree: [],

        // 当前选中的数据
        selectedStrategy: null,
        selectedStrategyAreas: [],
        selectedStrategyPricingRules: [],

        // UI状态
        isEditMode: false,
        showAreaSelector: false,

        // 表单数据
        editForm: {
            strategyId: null,
            selectedAreaIds: new Set(),
            weightRules: []
        },

        // 区域选择器状态
        areaSelector: {
            expandedProvinces: new Set(),
            expandedCities: new Set(),
            selectedProvinces: new Set(),
            selectedCities: new Set(),
            selectedDistricts: new Set()
        }
    };

    // ================================ API调用方法 ================================

    /**
     * 加载所有策略
     */
    async function loadStrategies() {
        try {
            const result = await unifiedApiCall('getStrategies', '/strategy/list', {});

            if ((result.code === 200 || result.code === 0) && result.data) {
                state.strategies = result.data;
                return result.data;
            }
            console.warn('⚠️ 策略接口返回格式异常:', result);
            state.strategies = [];
            return [];
        } catch (error) {
            console.error('加载策略失败:', error);
            // 所有错误都返回空数组，不阻塞应用启动
            console.warn('⚠️ 策略数据不可用，应用将以降级模式运行');
            state.strategies = [];
            return [];
        }
    }

    /**
     * 加载区域树结构
     */
    async function loadAreaTree() {
        try {
            const result = await unifiedApiCall('getAreaTree', '/area/list-tree', {});

            if ((result.code === 200 || result.code === 0) && result.data) {
                state.areaTree = result.data;
                return result.data;
            }
            console.warn('⚠️ 区域接口返回格式异常:', result);
            state.areaTree = [];
            return [];
        } catch (error) {
            console.error('加载区域数据失败:', error);
            // 所有错误都返回空数组，不阻塞应用启动
            console.warn('⚠️ 区域数据不可用，应用将以降级模式运行');
            state.areaTree = [];
            return [];
        }
    }

    /**
     * 根据策略ID加载关联的区域定价数据
     */
    async function loadStrategyPricingData(strategyId) {
        try {
            // 使用统一API服务
            const result = await unifiedApiCall(
                'getMappings',
                '/api/pricing-area-mapping/list',
                {strategyId: strategyId}
            );

            if (result.code === 200 || result.code === 0) {
                return result.data || [];
            }
            throw new Error(result.message || '加载策略定价数据失败');
        } catch (error) {
            console.error('加载策略定价数据失败:', error);
            throw error;
        }
    }

    /**
     * 统一加载策略数据（区域定价和重量规则）- 只调用一次API
     * 解决问题一：不再分别调用多个接口，统一使用/strategy-area-pricing/list
     */
    async function loadUnifiedStrategyData(strategyId) {
        try {
            console.log('📊 开始统一加载策略数据, 策略ID:', strategyId);

            // 只调用一次统一API
            const result = await unifiedApiCall(
                'getStrategyAreaPricingList',
                '/strategy-area-pricing/list',
                {strategyId: strategyId}
            );

            if (result.code !== 200 && result.code !== 0) {
                throw new Error(result.message || result.msg || '加载策略数据失败');
            }

            const data = result.data || [];

            // 处理区域定价数据
            const areaPricingData = data.map(item => ({
                id: item.id,
                name: item.name || '未命名定价',
                areas: item.areaNames || [], // 后端已经提供了区域名称列表
                areaCount: item.areaCount || 0,
                status: item.status || 1,
                description: item.description || '',
                strategyId: item.strategyId,
                firstWeightKg: item.firstWeightKg,
                firstWeightFee: item.firstWeightFee,
                additionalWeightKg: item.additionalWeightKg,
                additionalWeightFee: item.additionalWeightFee,
                volumetricWeightRatio: item.volumetricWeightRatio || 0,
                createTime: item.createTime
            }));

            // 处理重量规则数据
            const weightRulesData = [];
            data.forEach(item => {
                if (item.weightSegmentRules && Array.isArray(item.weightSegmentRules)) {
                    item.weightSegmentRules.forEach(rule => {
                        weightRulesData.push({
                            ...rule,
                            // 保持与原有接口相同的数据结构
                            pricingName: item.name,
                            pricingId: item.id,
                            // 从关联的strategy_area_pricing表获取首重和续重信息
                            firstWeightKg: parseFloat(item.firstWeightKg || 0),
                            firstWeightFee: parseFloat(item.firstWeightFee || 0),
                            additionalWeightKg: parseFloat(item.additionalWeightKg || 0),
                            additionalWeightFee: parseFloat(item.additionalWeightFee || 0),
                            volumetricWeightRatio: parseFloat(item.volumetricWeightRatio || 0),
                            applyAreas: item.name || '未知地区',
                            status: item.status || 1
                        });
                    });
                }
            });

            console.log('✅ 统一数据处理完成 - 区域定价:', areaPricingData.length, '条, 重量规则:', weightRulesData.length, '条');

            return {
                areaPricing: areaPricingData,
                weightRules: weightRulesData
            };
        } catch (error) {
            console.error('❌ 统一加载策略数据失败:', error);
            throw error;
        }
    }

    /**
     * 根据策略ID加载重量规则 - 现在从策略区域定价接口获取
     */
    async function loadWeightRules(strategyId) {
        try {
            // 使用统一的策略区域定价接口获取重量规则
            const result = await unifiedApiCall(
                'getStrategyAreaPricingList',
                '/strategy-area-pricing/list',
                {strategyId: strategyId}
            );

            if (result.code === 200 || result.code === 0) {
                // 从策略区域配置数据中提取重量规则
                const weightRules = [];
                (result.data || []).forEach(item => {
                    if (item.weightSegmentRules && Array.isArray(item.weightSegmentRules)) {
                        item.weightSegmentRules.forEach(rule => {
                            weightRules.push({
                                ...rule,
                                // 保持与原有接口相同的数据结构
                                pricingName: item.name,
                                pricingId: item.id
                            });
                        });
                    }
                });
                return weightRules;
            }
            throw new Error(result.message || '加载重量规则失败');
        } catch (error) {
            console.error('加载重量规则失败:', error);
            throw error;
        }
    }

    /**
     * 保存策略区域配置（V3数据模型）
     */
    async function saveStrategyConfiguration(strategyId, areas, weightRules) {
        try {
            // V3数据模型中，需要同时更新多个表
            const saveData = {
                strategyId: strategyId,
                areas: areas,
                weightRules: weightRules
            };

            // 使用统一API服务
            const result = await unifiedApiCall(
                'saveV3StrategyConfiguration',
                '/v3/strategy-configuration/save',
                saveData
            );

            if (result.code === 200 || result.code === 0) {
                return result;
            }
            throw new Error(result.message || '保存策略配置失败');
        } catch (error) {
            console.error('保存策略配置失败:', error);
            throw error;
        }
    }

    // ================================ 数据处理方法 ================================

    /**
     * 选择策略
     */
    async function selectStrategy(strategyIdOrObj) {
        let strategy;

        // 处理参数，支持传入ID或对象
        if (typeof strategyIdOrObj === 'number') {
            strategy = state.strategies.find(s => s.id === strategyIdOrObj);
        } else if (typeof strategyIdOrObj === 'object' && strategyIdOrObj.id) {
            strategy = strategyIdOrObj;
        } else {
            console.error('无效的策略参数:', strategyIdOrObj);
            return;
        }

        if (!strategy || !strategy.id) {
            console.error('找不到策略:', strategyIdOrObj);
            return;
        }

        try {
            state.selectedStrategy = strategy;

            // 使用统一API一次性加载策略相关的区域定价数据和重量规则
            const unifiedData = await loadUnifiedStrategyData(strategy.id);
            const areaPricingData = unifiedData.areaPricing;
            const weightRules = unifiedData.weightRules;

            console.log('📊 策略选择 - 区域定价数据:', areaPricingData);
            console.log('📊 策略选择 - 重量规则数据:', weightRules);

            state.selectedStrategyPricingRules = areaPricingData;

            // V3数据模型：直接使用后端返回的区域名称数据，无需查找areaTree
            const allAreaNames = [];

            // 从定价数据中提取所有区域名称
            areaPricingData.forEach(pricing => {
                if (pricing.areas && Array.isArray(pricing.areas)) {
                    // 后端已经返回了格式化的区域名称列表（areaNames）
                    allAreaNames.push(...pricing.areas);
                }
            });

            // 去重并构建区域显示数据
            const uniqueAreaNames = [...new Set(allAreaNames)];
            state.selectedStrategyAreas = uniqueAreaNames.map((areaName, index) => ({
                id: `area_${index}`, // 生成唯一ID
                name: areaName,
                level: 1, // 默认级别
                fullName: areaName // 使用后端格式化好的名称
            }));

            console.log('🌍 策略选择 - 处理后的区域数据:', state.selectedStrategyAreas);

            // 更新编辑表单
            state.editForm.strategyId = strategy.id;
            state.editForm.weightRules = weightRules.map(rule => ({
                id: rule.id,
                upperBound: rule.upperBound,
                freight: rule.freight,
                firstWeightKg: rule.firstWeightKg || 0,
                firstWeightFee: rule.firstWeightFee || rule.freight || 0,
                additionalWeightKg: rule.additionalWeightKg || 0,
                additionalWeightFee: rule.additionalWeightFee || 0,
                volumetricWeightRatio: rule.volumetricWeightRatio || 0
            }));

            console.log('✅ 策略选择完成 - 编辑表单数据:', state.editForm);

            // 设置Vue应用的当前策略状态
            if (window.vueAppInstance) {
                // 直接设置v3CurrentStrategy
                if (window.vueAppInstance.v3CurrentStrategy && window.vueAppInstance.v3CurrentStrategy.value !== undefined) {
                    // 这是一个ref对象
                    window.vueAppInstance.v3CurrentStrategy.value = strategy;
                } else {
                    // 直接设置属性
                    window.vueAppInstance.v3CurrentStrategy = strategy;
                }
            } else {
                console.warn('⚠️ [调试] Vue应用实例不存在');
            }

            // 更新UI显示
            renderStrategyConfig();

        } catch (error) {
            console.error('选择策略失败:', error);
            showMessage('加载策略数据失败: ' + error.message, true);
        }
    }

    /**
     * 根据ID数组获取区域信息
     */
    function getAreasByIds(areaIds) {
        const areas = [];

        function findAreas(treeNodes, targetIds) {
            for (const node of treeNodes) {
                if (targetIds.includes(node.id)) {
                    areas.push({
                        id: node.id,
                        name: node.name,
                        level: node.level,
                        fullName: getAreaFullName(node)
                    });
                }
                if (node.children && node.children.length > 0) {
                    findAreas(node.children, targetIds);
                }
            }
        }

        findAreas(state.areaTree, areaIds);
        return areas;
    }

    /**
     * 按省份分组区域
     * 处理已格式化的区域名称（格式：省份-城市-区县）
     */
    function groupAreasByProvince(areas) {
        if (!areas || areas.length === 0) {
            return [];
        }

        const groups = {};

        areas.forEach(area => {
            let provinceName = '未知省份';
            let displayName = area.name || area.fullName || '未知区域';

            // 如果是已格式化的区域名称（包含分隔符），提取省份名称
            if (displayName.includes('-')) {
                const parts = displayName.split('-');
                provinceName = parts[0] || '未知省份';
            } else if (area.fullName && area.fullName.includes(' > ')) {
                // 处理 '省份 > 城市 > 区县' 格式
                const parts = area.fullName.split(' > ');
                provinceName = parts[0] || '未知省份';
            } else {
                // 如果无法解析省份，将整个名称作为省份使用
                provinceName = displayName;
            }

            // 确保省份名称不为undefined或空
            if (!provinceName || provinceName === 'undefined') {
                provinceName = '未知省份';
            }

            // 确保显示名称不为undefined
            if (!displayName || displayName === 'undefined') {
                displayName = '未知区域';
            }

            if (!groups[provinceName]) {
                groups[provinceName] = {
                    provinceName,
                    areas: []
                };
            }

            groups[provinceName].areas.push({
                ...area,
                name: displayName, // 确保name字段存在且有效
                displayName: displayName // 额外的显示字段
            });
        });

        console.log('🏷️ 按省份分组结果:', groups);
        return Object.values(groups);
    }

    /**
     * 获取区域全名
     */
    function getAreaFullName(area) {
        if (!area) return '';

        // 递归查找父级区域
        function findParents(treeNodes, targetId, parents = []) {
            for (const node of treeNodes) {
                if (node.id === targetId) {
                    return [...parents, node.name];
                }
                if (node.children && node.children.length > 0) {
                    const result = findParents(node.children, targetId, [...parents, node.name]);
                    if (result.length > 0) return result;
                }
            }
            return [];
        }

        const pathNames = findParents(state.areaTree, area.id);
        return pathNames.join(' > ');
    }

    // ================================ UI渲染方法 ================================

    /**
     * 渲染策略配置界面
     */
    function renderStrategyConfig() {
        renderStrategyList();
        renderAreaDisplay();
        renderPricingRules();
    }

    /**
     * 渲染策略列表
     */
    function renderStrategyList() {
        console.log('🎨 开始渲染策略列表, 策略数量:', state.strategies.length);

        const container = document.getElementById('v3-strategy-list');
        if (!container) {
            // 检查是否在策略配置页面
            const isStrategyConfigPage = window.location.pathname.includes('strategy') ||
                document.querySelector('#strategy-config-tab') ||
                (window.vueAppInstance && window.vueAppInstance.activeTab === 'strategy-config');

            if (isStrategyConfigPage) {
                console.error('❌ 找不到策略列表容器: v3-strategy-list');
                return;
            } else {
                // 如果不在策略配置页面，静默返回不显示警告
                console.debug('📝 当前不在策略配置页面，跳过渲染');
                return;
            }
        }

        if (state.strategies.length === 0) {
            console.log('⚠️ 策略列表为空，显示空状态');
            container.innerHTML = '<div class="empty-state">暂无策略数据</div>';
            return;
        }

        console.log('📄 策略数据:', state.strategies);

        const html = state.strategies.map(strategy => {
            const isSelected = state.selectedStrategy?.id === strategy.id;
            const pricingModel = strategy.pricingModel === 1 ? '首重续重' : '首重续重+重量区间';
            const description = strategy.description || '无备注';

            return `
                <div class="strategy-item ${isSelected ? 'selected' : ''}"
                     onclick="console.log('🔧 [调试] 策略项被点击，ID:', ${strategy.id}); V3StrategyConfigManager.selectStrategy(${strategy.id})">
                    <div class="strategy-info">
                        <div class="strategy-name" title="${strategy.name || '未命名策略'}">
                            ${strategy.name || '未命名策略'}
                        </div>
                        <div class="strategy-time">
                            计费模式：${pricingModel}
                        </div>
                        <div class="strategy-note" title="${description}">
                            备注：${description.length > 20 ? description.substring(0, 20) + '...' : description}
                        </div>
                    </div>
                    <div class="strategy-actions">
                        <button class="btn btn-primary btn-small" 
                                onclick="event.stopPropagation(); V3StrategyConfigManager.editStrategy(${strategy.id})"
                                title="编辑策略">
                            编辑策略
                        </button>
                    </div>
                </div>
            `;
        }).join('');

        console.log('✅ 策略列表HTML已生成，长度:', html.length);
        container.innerHTML = html;
        console.log('✅ 策略列表渲染完成');
    }

    /**
     * 渲染区域显示
     */
    function renderAreaDisplay() {
        const container = document.getElementById('v3-area-display');
        if (!container) return;

        if (!state.selectedStrategy) {
            container.innerHTML = '<div class="empty-state">请先选择一个策略</div>';
            return;
        }

        // 获取策略的地区定价数据
        loadStrategyAreaPricingData(state.selectedStrategy.id)
            .then(areaPricingData => {
                const html = `
                    <div class="area-pricing-table">
                        <table class="config-table">
                            <thead>
                                <tr>
                                    <th width="12%">配置名称</th>
                                    <th width="22%">地区</th>
                                    <th width="10%">首重重量(kg)</th>
                                    <th width="10%">首重资费(元)</th>
                                    <th width="10%">续重重量(kg)</th>
                                    <th width="10%">续重资费(元)</th>
                                    <th width="8%">抛重比</th>
                                    <th width="18%">描述</th>
                                </tr>
                            </thead>
                            <tbody>
                                ${areaPricingData.length > 0 ?
                    areaPricingData.map(item => `
                                        <tr>
                                            <td><span class="readonly-text">${item.name || '未命名定价'}</span></td>
                                            <td>
                                                <div class="area-info">
                                                    <div class="area-tags">
                                                        ${(item.areas || []).map(area => `<span class="area-tag">${area}</span>`).join('')}
                                                    </div>
                                                </div>
                                            </td>
                                            <td><span class="readonly-text">${item.firstWeightKg || 0}</span></td>
                                            <td><span class="readonly-text">${item.firstWeightFee || 0}</span></td>
                                            <td><span class="readonly-text">${item.additionalWeightKg || 0}</span></td>
                                            <td><span class="readonly-text">${item.additionalWeightFee || 0}</span></td>
                                            <td><span class="readonly-text">${item.volumetricWeightRatio || 0}</span></td>
                                            <td><span class="readonly-text" title="${item.description || ''}">${(item.description || '').length > 20 ? (item.description || '').substring(0, 20) + '...' : (item.description || '')}</span></td>
                                        </tr>
                                    `).join('') :
                    '<tr><td colspan="8" class="empty-cell"><div class="empty-state"><i class="icon-location"></i><p>暂无地区配置</p></div></td></tr>'
                }
                            </tbody>
                        </table>
                    </div>
                `;

                container.innerHTML = html;

                // 添加查看模式样式
                addViewModeStyles();
            })
            .catch(error => {
                console.error('加载地区配置数据失败:', error);
                container.innerHTML = `
                    <div class="error-state">
                        <p>加载地区配置失败，请稍后重试</p>
                    </div>
                `;

                // 添加查看模式样式
                addViewModeStyles();
            });
    }

    /**
     * 渲染计费规则
     */
    function renderPricingRules() {
        const container = document.getElementById('v3-pricing-rules');
        if (!container) return;

        if (!state.selectedStrategy) {
            container.innerHTML = '<div class="empty-state">请先选择一个策略</div>';
            return;
        }

        // 检查计费模式，只有“首重续重+重量区间”模式才显示重量区间规则
        if (state.selectedStrategy.pricingModel === 1) {
            // 计费模式为“首重续重”，不显示重量区间规则
            container.innerHTML = `
                <div class="empty-state-notice">
                    <div class="notice-content">
                        <i class="icon-info"></i>
                        <p>当前策略使用“首重续重”计费模式</p>
                        <p class="notice-subtitle">重量区间规则仅在“首重续重+重量区间”模式下显示</p>
                    </div>
                </div>
            `;

            // 添加查看模式样式
            addViewModeStyles();
            return;
        }

        // 获取策略的重量区间规则数据
        loadStrategyWeightRulesData(state.selectedStrategy.id)
            .then(weightRulesData => {
                // 同时加载地区定价数据，用于获取配置名称
                return loadStrategyAreaPricingData(state.selectedStrategy.id)
                    .then(areaPricingData => {
                        // 创建配置ID到名称的映射
                        const pricingNameMap = {};
                        areaPricingData.forEach(pricing => {
                            pricingNameMap[pricing.id] = pricing.name || '未命名配置';
                        });

                        const html = `
                            <div class="weight-rules-table">
                                <table class="config-table">
                                    <thead>
                                        <tr>
                                            <th width="40%">关联地区配置名称</th>
                                            <th width="30%">重量上限（kg）</th>
                                            <th width="30%">区间费用（元）</th>
                                        </tr>
                                    </thead>
                                    <tbody>
                                        ${weightRulesData.length > 0 ?
                            weightRulesData.map(item => {
                                // 获取关联的地区配置名称
                                const pricingName = pricingNameMap[item.pricingId] || item.applyAreas || '未知地区';

                                return `
                                                    <tr>
                                                        <td><span class="readonly-text">${pricingName}</span></td>
                                                        <td><span class="readonly-text">${item.upperBound || 0}</span></td>
                                                        <td><span class="readonly-text">${item.freight || 0}</span></td>
                                                    </tr>
                                                `;
                            }).join('') :
                            '<tr><td colspan="3" class="empty-cell"><div class="empty-state"><i class="icon-weight"></i><p>暂无重量区间规则</p></div></td></tr>'
                        }
                                    </tbody>
                                </table>
                            </div>
                        `;

                        container.innerHTML = html;

                        // 添加查看模式样式
                        addViewModeStyles();
                    })
                    .catch(error => {
                        console.warn('加载地区定价数据失败，使用默认显示:', error);

                        // 如果加载地区定价数据失败，使用默认显示
                        const html = `
                            <div class="weight-rules-table">
                                <table class="config-table">
                                    <thead>
                                        <tr>
                                            <th width="40%">关联地区配置名称</th>
                                            <th width="30%">重量上限（kg）</th>
                                            <th width="30%">区间费用（元）</th>
                                        </tr>
                                    </thead>
                                    <tbody>
                                        ${weightRulesData.length > 0 ?
                            weightRulesData.map(item => `
                                                <tr>
                                                    <td><span class="readonly-text">${item.applyAreas || '未知地区'}</span></td>
                                                    <td><span class="readonly-text">${item.upperBound || 0}</span></td>
                                                    <td><span class="readonly-text">${item.freight || 0}</span></td>
                                                </tr>
                                            `).join('') :
                            '<tr><td colspan="3" class="empty-cell"><div class="empty-state"><i class="icon-weight"></i><p>暂无重量区间规则</p></div></td></tr>'
                        }
                                    </tbody>
                                </table>
                            </div>
                        `;

                        container.innerHTML = html;

                        // 添加查看模式样式
                        addViewModeStyles();
                    });
            })
            .catch(error => {
                console.error('加载重量区间规则数据失败:', error);
                container.innerHTML = `
                    <div class="error-state">
                        <p>加载重量区间规则失败，请稍后重试</p>
                    </div>
                `;

                // 添加查看模式样式
                addViewModeStyles();
            });
    }

    // ================================ 编辑功能 ================================

    /**
     * 编辑策略
     */
    function editStrategy(strategyId) {
        const strategy = state.strategies.find(s => s.id === strategyId);
        if (!strategy) {
            console.error('找不到策略:', strategyId);
            return;
        }

        // 调用Vue应用的策略编辑方法
        if (window.FreightApp && window.FreightApp.setup) {
            // 获取Vue应用实例
            const app = document.getElementById('app').__vueParentComponent;
            if (app && app.setupState) {
                // 设置编辑表单数据
                Object.assign(app.setupState.v3StrategyEditForm, {
                    id: strategy.id,
                    name: strategy.name,
                    description: strategy.description,
                    pricingModel: strategy.pricingModel,
                    weightRules: state.editForm.weightRules.slice(), // 复制重量规则
                    selectedAreas: state.selectedStrategyAreas.slice() // 复制选中区域
                });

                // 显示编辑模态框
                app.setupState.showV3StrategyEditModal.value = true;
            }
        }

        console.log('编辑策略:', strategy);
    }

    /**
     * 编辑区域
     */
    function editAreas() {
        if (!state.selectedStrategy) {
            showMessage('请先选择一个策略', true);
            return;
        }

        // 调用Vue应用的区域选择器
        if (window.FreightApp && window.FreightApp.setup) {
            const app = document.getElementById('app').__vueParentComponent;
            if (app && app.setupState) {
                // 初始化区域选择器状态
                app.setupState.v3AreaState.selectedProvinces.clear();
                app.setupState.v3AreaState.selectedCities.clear();
                app.setupState.v3AreaState.selectedDistricts.clear();

                // 设置当前选中的区域
                state.selectedStrategyAreas.forEach(area => {
                    if (area.level === 1) {
                        app.setupState.v3AreaState.selectedProvinces.add(area.id);
                    } else if (area.level === 2) {
                        app.setupState.v3AreaState.selectedCities.add(area.id);
                    } else if (area.level === 3) {
                        app.setupState.v3AreaState.selectedDistricts.add(area.id);
                    }
                });

                // 显示区域选择器
                app.setupState.showV3AreaSelector.value = true;
            }
        }

        console.log('编辑区域:', state.selectedStrategy, state.selectedStrategyAreas);
    }

    /**
     * 显示区域选择器模态框
     */
    function showAreaSelectorModal() {
        // TODO: 实现区域选择器模态框
        console.log('显示区域选择器');
    }

    // ================================ 工具函数 ================================

    /**
     * 格式化日期
     */
    function formatDate(dateStr) {
        if (!dateStr) return '';
        const date = new Date(dateStr);
        return date.toLocaleDateString('zh-CN');
    }

    /**
     * 格式化重量范围
     */
    function formatWeightRange(rule, index) {
        if (index === 0) {
            return `0.0000 ≤ 重量 ≤ ${rule.upperBound}`;
        }
        const prevRule = state.editForm.weightRules[index - 1];
        return `${prevRule.upperBound} ≤ 重量 ≤ ${rule.upperBound}`;
    }

    /**
     * 格式化金额
     */
    function formatMoney(amount) {
        return parseFloat(amount).toFixed(4);
    }

    /**
     * 编辑计费规则
     */
    function editPricingRules() {
        if (!state.selectedStrategy) return;

        // TODO: 实现计费规则编辑对话框
        console.log('编辑计费规则:', state.selectedStrategy);
    }

    /**
     * 显示消息
     */
    function showMessage(message, isError = false) {
        // 这里可以调用全局的消息显示方法
        console.log(isError ? '错误:' : '成功:', message);
    }

    // ================================ 辅助方法 ================================

    /**
     * 显示消息
     */
    function showMessage(message, isError = false) {
        if (window.app && window.app.showMessage) {
            window.app.showMessage(message, isError);
        } else {
            console.log(isError ? '❌ ' + message : '✅ ' + message);
            if (isError) {
                alert('错误: ' + message);
            } else {
                console.log('信息: ' + message);
            }
        }
    }

    /**
     * 格式化日期
     */
    function formatDate(date) {
        if (!date) return '未知';

        try {
            const d = new Date(date);
            if (isNaN(d.getTime())) return '无效日期';

            const year = d.getFullYear();
            const month = String(d.getMonth() + 1).padStart(2, '0');
            const day = String(d.getDate()).padStart(2, '0');
            const hours = String(d.getHours()).padStart(2, '0');
            const minutes = String(d.getMinutes()).padStart(2, '0');

            return `${year}-${month}-${day} ${hours}:${minutes}`;
        } catch (error) {
            console.error('日期格式化失败:', error);
            return '格式错误';
        }
    }

    /**
     * 格式化金额
     */
    function formatMoney(amount) {
        if (amount === null || amount === undefined) return '0.00';

        try {
            const num = parseFloat(amount);
            if (isNaN(num)) return '0.00';
            return num.toFixed(2);
        } catch (error) {
            console.error('金额格式化失败:', error);
            return '0.00';
        }
    }

    /**
     * 策略编辑功能
     */
    function editStrategy(strategyId) {
        console.log('编辑策略:', strategyId);

        // 获取策略数据
        const strategy = state.strategies.find(s => s.id === strategyId);
        if (!strategy) {
            showMessage('未找到策略数据', true);
            return;
        }

        // 创建编辑弹框
        createStrategyEditModal(strategy);
    }

    /**
     * 创建策略编辑弹框
     */
    function createStrategyEditModal(strategy) {
        // 移除已存在的弹框
        const existingModal = document.getElementById('strategy-edit-modal');
        if (existingModal) {
            existingModal.remove();
        }

        // 初始化策略编辑弹框命名空间
        window.V3StrategyEditModal = {
            currentStrategy: strategy,

            // 打开地区选择器
            openAreaSelector: function (strategyId) {
                console.log('打开地区选择器，策略ID:', strategyId || strategy.id);
                // 获取Vue应用实例
                if (window.vueAppInstance && window.vueAppInstance.openV3AreaSelector) {
                    // 设置当前策略 - 添加安全检查
                    if (window.vueAppInstance.v3CurrentStrategy) {
                        window.vueAppInstance.v3CurrentStrategy.value = strategy;
                    } else {
                        console.warn('⚠️ v3CurrentStrategy 未初始化');
                        return;
                    }

                    // 判断是新增还是编辑模式
                    const isEditMode = this.currentEditingPricingId;

                    if (isEditMode) {
                        console.log('🔧 编辑模式：地区配置ID =', this.currentEditingPricingId);
                        // 编辑模式：如果有当前编辑的配置ID，获取并回显地区信息
                        // 保留现有的编辑逻辑...
                    } else {
                        console.log('🆕 新增模式：清空地区选择');
                        // 新增模式：彻底清空地区选择器状态
                        if (window.vueAppInstance.v3AreaState) {
                            window.vueAppInstance.v3AreaState.selectedProvinces.clear();
                            window.vueAppInstance.v3AreaState.selectedCities.clear();
                            window.vueAppInstance.v3AreaState.selectedDistricts.clear();
                            window.vueAppInstance.v3AreaState.expandedProvinces.clear();
                            window.vueAppInstance.v3AreaState.expandedCities.clear();
                        }

                        // 清除当前编辑的配置ID
                        this.currentEditingPricingId = null;

                        // 确保没有其他残留状态
                        if (window.vueAppInstance.v3CurrentEditingAreaId) {
                            window.vueAppInstance.v3CurrentEditingAreaId = null;
                        }
                    }

                    // 只有在编辑模式下才执行回显操作
                    if (this.currentEditingPricingId) {
                        console.log('📝 编辑模式：回显地区信息，配置ID:', this.currentEditingPricingId);
                        // 传递一个标志表示这是编辑模式，避免在loadAndEchoAreaInfo中跳过回显
                        this.loadAndEchoAreaInfo(this.currentEditingPricingId, true);
                    } else {
                        console.log('🆕 新增模式：跳过回显操作，保持清空状态');
                        // 新增模式下确保彻底清空状态
                    }


                    // 检查并设置回调函数，在选择地区后重新加载数据
                    // 确保回调函数被正确初始化和设置
                    if (!window.vueAppInstance.v3AreaSelectionCallback) {
                        console.log('🔧 初始化 v3AreaSelectionCallback...');
                        window.vueAppInstance.v3AreaSelectionCallback = {value: null};
                    }

                    // 优化回调函数：避免多次API调用，使用前端缓存更新
                    window.vueAppInstance.v3AreaSelectionCallback.value = async function () {
                        console.log('🚀 [性能优化] 地区选择完成，使用前端缓存更新界面...');
                        try {
                            // 检查是否是编辑模式
                            const isEditMode = window.V3StrategyEditModal && window.V3StrategyEditModal.currentEditingPricingId;

                            if (isEditMode) {
                                console.log('📝 编辑模式：直接更新前端显示，避免API调用');
                                // 编辑模式：直接更新对应行的地区显示，不调用API
                                await window.V3StrategyEditModal.updateEditedAreaDisplay();
                            } else {
                                console.log('🆕 新增模式：更新暂存配置显示');
                                // 新增模式：更新暂存配置的前端显示
                                await window.V3StrategyEditModal.updatePendingAreaConfigsDisplay();

                                // 只在新增模式下更新重量区间下拉框
                                setTimeout(() => {
                                    initPricingSelectOptions();
                                }, 100);
                            }

                            showMessage('地区配置更新成功');
                            console.log('✅ [性能优化] 地区信息前端缓存更新完成');
                        } catch (error) {
                            console.error('❌ 前端缓存更新失败，回退到API重新加载:', error);
                            // 回退方案：调用API重新加载
                            await window.V3StrategyEditModal.fallbackReloadData();
                        }
                    };
                    // 显示地区选择器
                    window.vueAppInstance.showV3AreaSelector = true;
                    console.log('通过 Vue 实例打开地区选择器');
                } else {
                    console.log('尝试直接调用 openV3AreaSelector...');
                    // 尝试直接调用
                    if (typeof openV3AreaSelector === 'function') {
                        openV3AreaSelector();
                    } else if (window.openV3AreaSelector) {
                        window.openV3AreaSelector();
                    } else {
                        showMessage('地区选择器暂时不可用，请刷新页面重试', true);
                    }
                }
            },

            // 添加重量规则
            addWeightRule: function () {
                console.log('添加重量规则');

                // 检查是否有选中的策略
                if (!strategy || !strategy.id) {
                    console.error('❤️ 未选中策略');
                    showMessage('请先选择一个策略', true);
                    return;
                }

                // 直接在表格中添加一行新的重量规则
                this.addWeightRuleRow();
            },

            // 直接在表格中添加重量规则行
            addWeightRuleRow: function () {
                const tbody = document.getElementById('weight-rules-list');
                if (!tbody) {
                    console.error('未找到重量规则表格');
                    return;
                }

                // 清理空状态显示
                const emptyRow = tbody.querySelector('.empty-cell');
                if (emptyRow) {
                    emptyRow.parentElement.remove();
                }

                // 生成临时ID（负数表示新增）
                const tempId = -Date.now();

                // 检查是否有待新增的地区配置，如果有则自动关联
                let relatedAreaConfigTempId = null;
                if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.size > 0) {
                    // 获取最新的新增地区配置的tempId
                    const tempIds = Array.from(window.pendingNewAreaConfigs.keys());
                    relatedAreaConfigTempId = tempIds[tempIds.length - 1]; // 取最后一个
                    console.log('🔗 自动关联到新增地区配置，tempId:', relatedAreaConfigTempId);
                }

                // 创建新行
                const newRow = document.createElement('tr');
                newRow.setAttribute('data-rule-id', tempId);
                newRow.classList.add('new-weight-rule');

                newRow.innerHTML = `
                    <td>
                        <select class="table-select pricing-select" 
                                data-field="pricingId" data-id="${tempId}" 
                                data-current-pricing="" 
                                ${relatedAreaConfigTempId ? `data-area-config-temp-id="${relatedAreaConfigTempId}"` : ''}
                                onchange="handlePricingChange(this)">
                            <option value="">请选择地区配置</option>
                            <!-- 动态加载地区配置选项 -->
                        </select>
                    </td>
                    <td>
                        <input type="number" value="0" 
                               step="0.1" min="0" class="table-input weight-input" 
                               data-field="upperBound" data-id="${tempId}" 
                               placeholder="请输入重量上限">
                    </td>
                    <td>
                        <input type="number" value="0" 
                               step="0.1" min="0" class="table-input fee-input" 
                               data-field="freight" data-id="${tempId}" 
                               placeholder="请输入区间费用">
                    </td>
                    <td>
                        <div class="action-buttons">
                            <button class="btn-small btn-success" 
                                    onclick="window.V3StrategyEditModal.saveNewWeightRule(${tempId})" 
                                    title="保存规则">
                                <i class="icon-save"></i> 保存
                            </button>
                            <button class="btn-small btn-danger" 
                                    onclick="window.V3StrategyEditModal.cancelNewWeightRule(${tempId})" 
                                    title="取消">
                                <i class="icon-cancel"></i> 取消
                            </button>
                        </div>
                    </td>
                `;

                // 添加到表格末尾
                tbody.appendChild(newRow);

                // 绑定事件
                bindTableInputEvents();

                // 初始化新行的地区配置下拉选项（使用延迟确保 DOM 更新完成）
                setTimeout(() => {
                    initPricingSelectOptions();

                    // 如果有关联的新增地区配置，自动选中它
                    if (relatedAreaConfigTempId) {
                        const select = newRow.querySelector('select');
                        const tempOption = Array.from(select.options).find(option =>
                            option.getAttribute('data-temp-id') === relatedAreaConfigTempId
                        );
                        if (tempOption) {
                            select.value = tempOption.value;
                            console.log('🎯 自动选中新增地区配置:', tempOption.textContent);
                        }
                    }
                }, 100);

                // 聚焦到第一个输入框
                const firstInput = newRow.querySelector('input');
                if (firstInput) {
                    firstInput.focus();
                }

                console.log('新重量规则行已添加，临时ID:', tempId,
                    relatedAreaConfigTempId ? '，关联地区配置:' + relatedAreaConfigTempId : '');
            },

            // 初始化新行的地区配置选项
            initNewRowPricingOptions: async function (tempId) {
                try {
                    const select = document.querySelector(`select[data-id="${tempId}"]`);
                    if (!select) return;

                    // 获取当前策略的地区配置数据
                    const areaPricingData = await loadStrategyAreaPricingData(strategy.id);

                    // 清空现有选项（保留默认选项）
                    while (select.children.length > 1) {
                        select.removeChild(select.lastChild);
                    }

                    // 添加地区配置选项
                    areaPricingData.forEach(pricing => {
                        const option = document.createElement('option');
                        option.value = pricing.id;
                        // 只显示配置名称
                        option.textContent = pricing.name || '未命名配置';
                        select.appendChild(option);
                    });
                } catch (error) {
                    console.error('初始化新行地区配置选项失败:', error);
                }
            },

            // 保存新重量规则（修改为不直接调用后端，仅确认数据）
            saveNewWeightRule: function (tempId) {
                try {
                    const row = document.querySelector(`tr[data-rule-id="${tempId}"]`);
                    if (!row) {
                        throw new Error('未找到规则行');
                    }

                    // 收集表单数据进行验证
                    const pricingSelect = row.querySelector('select[data-field="pricingId"]');
                    const upperBoundInput = row.querySelector('input[data-field="upperBound"]');
                    const freightInput = row.querySelector('input[data-field="freight"]');

                    // 数据验证
                    if (!pricingSelect.value) {
                        throw new Error('请选择地区配置');
                    }
                    if (!upperBoundInput.value || parseFloat(upperBoundInput.value) < 0) {
                        throw new Error('重量上限不能为负数');
                    }
                    if (!freightInput.value || parseFloat(freightInput.value) < 0) {
                        throw new Error('区间费用不能为负数');
                    }

                    console.log('验证通过，标记新重量规则为已确认:', tempId);

                    // 移除临时状态样式，标记为已确认的新规则
                    row.classList.remove('new-weight-rule');
                    row.classList.add('confirmed-new-rule');

                    // 修改操作按钮为显示确认状态
                    const actionButtons = row.querySelector('.action-buttons');
                    if (actionButtons) {
                        actionButtons.innerHTML = `
                            <span class="status-text text-success">
                                <i class="icon-check"></i> 已确认，等待保存
                            </span>
                        `;
                    }

                    // 标记所有输入框为已修改，但不设置只读（允许继续修改）
                    const inputs = row.querySelectorAll('input, select');
                    inputs.forEach(input => {
                        input.classList.add('modified');
                        // 移除只读限制，允许继续修改
                        input.removeAttribute('readonly');
                    });

                    showMessage('重量规则已确认，请点击"保存所有配置"按钮进行统一保存');

                } catch (error) {
                    console.error('验证新重量规则失败:', error);
                    showMessage('验证失败: ' + error.message, true);
                }
            },

            // 取消新重量规则
            cancelNewWeightRule: function (tempId) {
                const row = document.querySelector(`tr[data-rule-id="${tempId}"]`);
                if (row) {
                    row.remove();

                    // 检查是否需要显示空状态
                    const tbody = document.getElementById('weight-rules-list');
                    if (tbody && tbody.children.length === 0) {
                        tbody.innerHTML = `
                            <tr>
                                <td colspan="4" class="empty-cell">
                                    <div class="empty-state">
                                        <i class="icon-weight"></i>
                                        <p>暂无重量区间配置</p>
                                        <p class="empty-hint">重量区间适用于进阶计费模式</p>
                                        <button class="btn btn-secondary btn-small" onclick="window.V3StrategyEditModal.addWeightRule()">
                                            添加第一个区间规则
                                        </button>
                                    </div>
                                </td>
                            </tr>
                        `;
                    }
                }
                console.log('已取消新重量规则，临时ID:', tempId);
            },

            // 加载并回显地区信息
            loadAndEchoAreaInfo: async function (pricingId, isEditModeCall = false) {
                console.log('🔄 [V3.1.0] 加载地区信息回显，配置ID:', pricingId, '编辑模式调用:', isEditModeCall);
                console.log('🛠️ 使用最新的省级区域回显逻辑');

                // 如果是新增模式，直接返回，不执行任何数据获取和回显操作
                const isEditMode = isEditModeCall || (window.V3StrategyEditModal && window.V3StrategyEditModal.currentEditingPricingId);
                if (!isEditMode) {
                    console.log('🆕 [新增模式] 跳过所有数据获取和回显操作');
                    return;
                }

                try {
                    // 优先使用前端缓存（性能优化）
                    let pricingData = null;

                    // 先从暂存的数据中查找
                    if (window.pendingAreaChanges && window.pendingAreaChanges.has(pricingId)) {
                        const pendingChange = window.pendingAreaChanges.get(pricingId);
                        pricingData = {
                            id: pricingId,
                            areaIds: pendingChange.selectedAreaIds
                        };
                        console.log('📋 从暂存数据获取地区信息:', pricingData);
                    }

                    // 如果暂存数据中没有，再从后端获取
                    if (!pricingData) {
                        // 使用list接口获取当前策略的所有地区配置，然后找到指定配置ID的数据
                        if (!window.V3StrategyEditModal || !window.V3StrategyEditModal.currentStrategy) {
                            console.warn('⚠️ 未找到当前策略信息，无法加载地区配置');
                            return;
                        }

                        const strategy = window.V3StrategyEditModal.currentStrategy;
                        console.log('📋 从后端获取地区配置数据...');

                        // ========== 问题修复：使用统一API调用 ==========
                        const result = await unifiedApiCall(
                            'getStrategyAreaPricingList',
                            '/strategy-area-pricing/list',
                            {strategyId: strategy.id}
                        );
                        // ========== 问题修复结束 ==========
                        if (result.code === 0 && result.data) {
                            // 从返回的配置列表中找到指定配置ID的数据
                            pricingData = result.data.find(config => config.id == pricingId);

                            if (!pricingData) {
                                console.warn('⚠️ 未找到配置ID为', pricingId, '的地区配置数据');
                                return;
                            }
                        } else {
                            console.warn('⚠️ 无法获取地区配置列表:', result.msg);
                            return;
                        }
                    }

                    console.log('📋 找到配置数据:', pricingData);

                    // [问题修复] 只有在新增模式下才需要清空地区状态和回显
                    // 编辑模式下应该完全跳过清理和回显逻辑，保持当前状态
                    // 注意：pricingId 是策略ID，currentEditingPricingId 是配置ID，两者不同
                    // 如果是从编辑模式调用的，则跳过清理逻辑
                    const isEditMode = isEditModeCall || (window.V3StrategyEditModal && window.V3StrategyEditModal.currentEditingPricingId);

                    if (!isEditMode) {
                        // 新增模式：清空状态并回显数据
                        if (window.vueAppInstance && window.vueAppInstance.v3AreaState) {
                            console.log('🧹 [优化] 新增模式：清空所有地区选中状态...');

                            // 记录清理前的状态
                            const beforeClear = {
                                provinces: window.vueAppInstance.v3AreaState.selectedProvinces.size,
                                cities: window.vueAppInstance.v3AreaState.selectedCities.size,
                                districts: window.vueAppInstance.v3AreaState.selectedDistricts.size
                            };
                            console.log('📊 [调试] 清理前状态:', beforeClear);

                            // 强制清空所有选中状态
                            window.vueAppInstance.v3AreaState.selectedProvinces.clear();
                            window.vueAppInstance.v3AreaState.selectedCities.clear();
                            window.vueAppInstance.v3AreaState.selectedDistricts.clear();
                            window.vueAppInstance.v3AreaState.expandedProvinces.clear();
                            window.vueAppInstance.v3AreaState.expandedCities.clear();

                            // 验证清理结果
                            const afterClear = {
                                provinces: window.vueAppInstance.v3AreaState.selectedProvinces.size,
                                cities: window.vueAppInstance.v3AreaState.selectedCities.size,
                                districts: window.vueAppInstance.v3AreaState.selectedDistricts.size
                            };
                            console.log('✅ [调试] 清理后状态:', afterClear);

                            // 确保所有状态都为0
                            const totalSelected = afterClear.provinces + afterClear.cities + afterClear.districts;
                            if (totalSelected > 0) {
                                console.error('❌ [调试] 状态清理失败，仍有遗留选中:', totalSelected);
                            } else {
                                console.log('✅ [调试] 状态清理成功，所有选中已清空');
                            }
                        }
                    } else {
                        console.log('📝 [优化] 编辑模式：跳过清理逻辑，但执行回显操作');
                        // 编辑模式下只跳过清理逻辑，但仍然需要执行回显操作
                    }

                    // 使用新增的areaIds参数进行地区回显（仅编辑模式需要）
                    if (!isEditMode) {
                        console.log('🆕 [新增模式] 跳过回显操作，保持清空状态');
                        return; // 新增模式下直接返回，不执行回显
                    }

                    if (pricingData.areaIds && Array.isArray(pricingData.areaIds) && pricingData.areaIds.length > 0) {
                        console.log('🌍 [编辑模式] 开始回显地区，areaIds:', pricingData.areaIds);

                        // [问题修复] 正确处理多级地区回显，不再假设都是省级
                        for (const areaId of pricingData.areaIds) {
                            console.log('🔍 分析地区 ID:', areaId);

                            // 使用地区树查找地区信息确定级别
                            const areaInfo = this.findAreaInTree(areaId);
                            if (areaInfo) {
                                console.log('🎯 回显地区:', areaInfo.name, '级别:', areaInfo.level);

                                if (areaInfo.level === 1) {
                                    // 省级区域
                                    window.vueAppInstance.v3AreaState.selectedProvinces.add(areaId);
                                    console.log('✅ 已选中省份:', areaInfo.name);
                                } else if (areaInfo.level === 2) {
                                    // 市级区域
                                    window.vueAppInstance.v3AreaState.selectedCities.add(areaId);
                                    // 同时展开父级省份
                                    const parentProvince = this.findParentProvince(areaId);
                                    if (parentProvince) {
                                        window.vueAppInstance.v3AreaState.expandedProvinces.add(parentProvince.id);
                                        console.log('✅ 已选中城市:', areaInfo.name, '展开父省:', parentProvince.name);
                                    }
                                } else if (areaInfo.level === 3) {
                                    // 区县级区域
                                    window.vueAppInstance.v3AreaState.selectedDistricts.add(areaId);
                                    // 同时展开父级省份和城市
                                    const parentProvince = this.findParentProvince(areaId);
                                    const parentCity = this.findParentCity(areaId);
                                    if (parentProvince) {
                                        window.vueAppInstance.v3AreaState.expandedProvinces.add(parentProvince.id);
                                    }
                                    if (parentCity) {
                                        window.vueAppInstance.v3AreaState.expandedCities.add(parentCity.id);
                                        console.log('✅ 已选中区县:', areaInfo.name, '展开父市:', parentCity.name);
                                    }
                                }
                            } else {
                                console.warn('⚠️ 未在地区树中找到地区 ID:', areaId, '默认按省级处理');
                                // 如果未找到，默认按省级处理
                                window.vueAppInstance.v3AreaState.selectedProvinces.add(areaId);
                            }
                        }

                        console.log('✅ 地区信息回显完成，选中的省份数量:',
                            window.vueAppInstance.v3AreaState.selectedProvinces.size,
                            '选中的城市数量:', window.vueAppInstance.v3AreaState.selectedCities.size,
                            '选中的区县数量:', window.vueAppInstance.v3AreaState.selectedDistricts.size
                        );
                    } else {
                        console.log('📝 该配置暂无关联的地区信息');
                    }
                } catch (error) {
                    console.error('❌ 加载地区信息回显失败:', error);
                }
            },

            // 在地区树中查找地区信息
            findAreaInTree: function (areaId) {
                console.log('🔍 [调试] 查找地区 ID:', areaId);

                if (!window.vueAppInstance) {
                    console.warn('⚠️ [调试] window.vueAppInstance 不存在');
                    return null;
                }

                if (!window.vueAppInstance.areaTree) {
                    console.warn('⚠️ [调试] areaTree 不存在');
                    return null;
                }

                const areaTree = window.vueAppInstance.areaTree.value || window.vueAppInstance.areaTree;
                console.log('🌳 [调试] 地区树结构:', {
                    isArray: Array.isArray(areaTree),
                    length: areaTree ? areaTree.length : 0,
                    firstItem: areaTree && areaTree[0] ? {
                        id: areaTree[0].id,
                        name: areaTree[0].name,
                        hasChildren: !!(areaTree[0].children && areaTree[0].children.length > 0)
                    } : null
                });

                if (!areaTree || !Array.isArray(areaTree) || areaTree.length === 0) {
                    console.warn('⚠️ [调试] 地区树数据为空或格式不正确');
                    return null;
                }

                // 递归查找地区
                function findArea(areas, level = 1, parentPath = '') {
                    for (const area of areas) {
                        const currentPath = parentPath ? `${parentPath} > ${area.name}` : area.name;

                        if (area.id === areaId) {
                            console.log('✅ [调试] 找到地区:', {
                                id: area.id,
                                name: area.name,
                                level: level,
                                path: currentPath
                            });
                            return {...area, level, path: currentPath};
                        }

                        if (area.children && area.children.length > 0) {
                            const found = findArea(area.children, level + 1, currentPath);
                            if (found) return found;
                        }
                    }
                    return null;
                }

                const result = findArea(areaTree);
                if (!result) {
                    console.warn('⚠️ [调试] 未找到地区 ID:', areaId);
                }

                return result;
            },

            // 查找父级省份
            findParentProvince: function (areaId) {
                if (!window.vueAppInstance || !window.vueAppInstance.areaTree) {
                    return null;
                }

                const areaTree = window.vueAppInstance.areaTree.value || [];

                for (const province of areaTree) {
                    // 直接是省份
                    if (province.id === areaId) {
                        return province;
                    }
                    // 在城市中查找
                    if (province.children) {
                        for (const city of province.children) {
                            if (city.id === areaId) {
                                return province;
                            }
                            // 在区县中查找
                            if (city.children) {
                                for (const district of city.children) {
                                    if (district.id === areaId) {
                                        return province;
                                    }
                                }
                            }
                        }
                    }
                }

                return null;
            },

            // 查找父级城市
            findParentCity: function (areaId) {
                if (!window.vueAppInstance || !window.vueAppInstance.areaTree) {
                    return null;
                }

                const areaTree = window.vueAppInstance.areaTree.value || [];

                for (const province of areaTree) {
                    if (province.children) {
                        for (const city of province.children) {
                            // 直接是城市
                            if (city.id === areaId) {
                                return city;
                            }
                            // 在区县中查找
                            if (city.children) {
                                for (const district of city.children) {
                                    if (district.id === areaId) {
                                        return city;
                                    }
                                }
                            }
                        }
                    }
                }

                return null;
            },

            // [性能优化] 更新编辑后的地区显示（避免API调用）
            updateEditedAreaDisplay: async function () {
                try {
                    const editingPricingId = this.currentEditingPricingId;
                    console.log('🔄 [最终修复] 开始更新编辑后的地区显示，配置ID:', editingPricingId);

                    if (!editingPricingId) {
                        console.warn('⚠️ [最终修复] 未找到当前编辑的配置id');
                        return;
                    }

                    // [问题修复] 正确收集所有选中的地区信息（包括省市区）
                    const selectedAreaIds = [];

                    // 收集省级选中
                    if (window.vueAppInstance && window.vueAppInstance.v3AreaState) {
                        window.vueAppInstance.v3AreaState.selectedProvinces.forEach(id => {
                            selectedAreaIds.push(id);
                            console.log('📍 [最终修复] 收集省级地区:', id);
                        });

                        // 收集市级选中
                        window.vueAppInstance.v3AreaState.selectedCities.forEach(id => {
                            selectedAreaIds.push(id);
                            console.log('📍 [最终修复] 收集市级地区:', id);
                        });

                        // 收集区县级选中
                        window.vueAppInstance.v3AreaState.selectedDistricts.forEach(id => {
                            selectedAreaIds.push(id);
                            console.log('📍 [最终修复] 收集区县级地区:', id);
                        });
                    }

                    if (selectedAreaIds.length === 0) {
                        console.warn('⚠️ [最终修复] 未选中任何地区，跳过更新');
                        return;
                    }

                    console.log('📋 [最终修复] 收集到所有选中的地区 ID:', selectedAreaIds);

                    // 获取地区名称
                    const areaNames = [];
                    for (const areaId of selectedAreaIds) {
                        const areaName = await window.findAreaNameById(areaId) || `地区ID:${areaId}`;
                        areaNames.push(areaName);
                        console.log('🏷️ [最终修复] 地区名称映射:', areaId, '->', areaName);
                    }

                    console.log('🏷️ [最终修复] 获取到的地区名称列表:', areaNames);

                    // [关键修复] 查找并更新DOM元素
                    const targetRowSelector = `tr[data-pricing-id="${editingPricingId}"]`;
                    console.log('🔍 [最终修复] 查找目标行，选择器:', targetRowSelector);

                    const targetRow = document.querySelector(targetRowSelector);
                    if (!targetRow) {
                        console.error('❌ [最终修复] 未找到目标行元素，选择器:', targetRowSelector);
                        const allRows = document.querySelectorAll('tr[data-pricing-id]');
                        console.log('🔍 [最终修复] 当前页面所有pricing行数量:', allRows.length);
                        allRows.forEach(row => {
                            console.log('  - 行ID:', row.getAttribute('data-pricing-id'));
                        });
                        return;
                    }

                    console.log('✅ [最终修复] 找到目标行元素');
                    console.log('🔍 [最终修复] 目标行完整HTML结构:');
                    console.log(targetRow.outerHTML.substring(0, 500) + '...');

                    // [最终修复] 精确定位地区标签容器 - 先尝试直接路径
                    let areaTagsContainer = targetRow.querySelector('.area-info .area-tags');

                    if (!areaTagsContainer) {
                        console.log('⚠️ [最终修复] 未找到 .area-info .area-tags，尝试其他路径...');

                        // 方案1: 尝试第二列的 .area-tags
                        const secondColumn = targetRow.querySelector('td:nth-child(2)');
                        if (secondColumn) {
                            console.log('✅ [最终修复] 找到第二列');
                            console.log('🔍 [最终修复] 第二列HTML:', secondColumn.innerHTML);

                            areaTagsContainer = secondColumn.querySelector('.area-tags');
                            if (areaTagsContainer) {
                                console.log('✅ [最终修复] 在第二列找到 .area-tags');
                            } else {
                                console.log('⚠️ [最终修复] 第二列中未找到 .area-tags，查找 .area-info');
                                const areaInfo = secondColumn.querySelector('.area-info');
                                if (areaInfo) {
                                    console.log('✅ [最终修复] 找到 .area-info');
                                    console.log('🔍 [最终修复] .area-info HTML:', areaInfo.innerHTML);

                                    areaTagsContainer = areaInfo.querySelector('.area-tags');
                                    if (areaTagsContainer) {
                                        console.log('✅ [最终修复] 在 .area-info 中找到 .area-tags');
                                    } else {
                                        console.log('⚠️ [最终修复] .area-info 中未找到 .area-tags，使用 .area-info 作为容器');
                                        areaTagsContainer = areaInfo;
                                    }
                                } else {
                                    console.log('⚠️ [最终修复] 第二列中未找到 .area-info，使用第二列作为容器');
                                    areaTagsContainer = secondColumn;
                                }
                            }
                        }
                    }

                    if (!areaTagsContainer) {
                        console.error('❌ [最终修复] 完全无法找到地区标签容器');
                        console.log('🔍 [最终修复] 完整目标行HTML:');
                        console.log(targetRow.outerHTML);
                        return;
                    }

                    console.log('✅ [最终修复] 找到地区标签容器:', areaTagsContainer.className);

                    // 生成新的地区标签HTML
                    const newAreaTagsHTML = areaNames.map(name => `<span class="area-tag">${name}</span>`).join('');
                    console.log('🔄 [最终修复] 新的地区标签HTML:', newAreaTagsHTML);

                    // [最终修复] 智能更新内容
                    if (areaTagsContainer.classList.contains('area-tags')) {
                        // 如果是 .area-tags 容器，直接替换内容
                        console.log('🔄 [最终修复] 更新前 .area-tags 内容:', areaTagsContainer.innerHTML);
                        areaTagsContainer.innerHTML = newAreaTagsHTML;
                        console.log('🔄 [最终修复] 更新后 .area-tags 内容:', areaTagsContainer.innerHTML);
                    } else if (areaTagsContainer.classList.contains('area-info')) {
                        // 如果是 .area-info 容器，查找或创建 .area-tags
                        let innerAreaTags = areaTagsContainer.querySelector('.area-tags');
                        if (innerAreaTags) {
                            console.log('🔄 [最终修复] 更新 .area-info 内的 .area-tags');
                            innerAreaTags.innerHTML = newAreaTagsHTML;
                        } else {
                            console.log('🔄 [最终修复] 在 .area-info 中创建新的 .area-tags');
                            areaTagsContainer.innerHTML = `<div class="area-tags">${newAreaTagsHTML}</div>`;
                        }
                    } else {
                        // 其他情况，创建完整的地区信息结构
                        console.log('🔄 [最终修复] 创建完整的地区信息结构');
                        areaTagsContainer.innerHTML = `<div class="area-info"><div class="area-tags">${newAreaTagsHTML}</div></div>`;
                    }

                    // [最终修复] 添加视觉更新效果
                    areaTagsContainer.style.backgroundColor = '#e8f5e8';
                    areaTagsContainer.style.transition = 'background-color 0.3s ease';
                    setTimeout(() => {
                        areaTagsContainer.style.backgroundColor = '';
                    }, 1500);

                    console.log('✅ [最终修复] 地区显示更新完成！');

                    // 存储编辑更改到全局状态，供保存时使用
                    if (!window.pendingAreaChanges) {
                        window.pendingAreaChanges = new Map();
                    }
                    window.pendingAreaChanges.set(editingPricingId, {
                        pricingId: editingPricingId,
                        selectedAreaIds: selectedAreaIds,
                        operator: 'admin'
                    });

                    console.log('📝 [最终修复] 编辑模式：已标记地区更改，等待统一保存');

                } catch (error) {
                    console.error('❌ [最终修复] 更新编辑后的地区显示失败:', error);
                    throw error;
                }
            },

            // 合并暂存配置和数据库数据
            mergePendingConfigsWithDbData: function (dbData) {
                try {
                    console.log('🔄 合并暂存配置和数据库数据');

                    // 如果没有暂存数据，直接返回数据库数据
                    if (!window.pendingNewAreaConfigs || window.pendingNewAreaConfigs.size === 0) {
                        return dbData;
                    }

                    // 创建结果数组，包含数据库数据
                    const result = [...dbData];

                    // 添加所有暂存配置到结果中
                    for (const config of window.pendingNewAreaConfigs.values()) {
                        result.push(config);
                    }

                    console.log('✅ 数据合并完成，总数:', result.length);
                    return result;
                } catch (error) {
                    console.error('❌ 合并数据失败:', error);
                    return dbData; // 出错时返回原始数据库数据
                }
            },

            // [性能优化] 更新暂存配置的显示（避免API调用）
            updatePendingAreaConfigsDisplay: async function () {
                try {
                    // 只更新暂存配置的显示，不重新加载所有数据
                    if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.size > 0) {
                        console.log('📝 更新暂存配置显示，数量:', window.pendingNewAreaConfigs.size);

                        // 合并数据库数据和暂存数据
                        const dbData = await loadStrategyAreaPricingData(strategy.id);
                        const mergedData = this.mergePendingConfigsWithDbData(dbData);

                        // 重新渲染表格（包含暂存的配置）
                        await renderAreaPricingTable(mergedData);

                        console.log('✅ 暂存配置显示更新完成');
                    }
                } catch (error) {
                    console.error('❌ 更新暂存配置显示失败:', error);
                    throw error;
                }
            },

            // [回退方案] API重新加载数据
            fallbackReloadData: async function () {
                try {
                    console.log('🔄 执行回退方案：API重新加载数据...');

                    // 显示加载状态
                    const areaPricingList = document.getElementById('area-pricing-list');
                    if (areaPricingList) {
                        areaPricingList.innerHTML = '<tr><td colspan="9" class="loading-cell">正在重新加载数据...</td></tr>';
                    }

                    // 重新加载地区配置数据
                    const areaPricingData = await loadStrategyAreaPricingData(strategy.id);
                    await renderAreaPricingTable(areaPricingData);

                    // 重新加载重量区间规则数据
                    const weightRulesData = await loadStrategyWeightRulesData(strategy.id);
                    renderWeightRulesTable(weightRulesData);

                    // 重新初始化重量区间下拉框数据
                    setTimeout(() => {
                        initPricingSelectOptions();
                    }, 200);

                    console.log('✅ 回退方案执行完成');

                } catch (error) {
                    console.error('❌ 回退方案也失败:', error);
                    showMessage('数据更新失败，请手动刷新页面: ' + error.message, true);
                }
            },

            // 编辑地区定价配置
            editAreaPricing: function (pricingId) {
                console.log('编辑地区定价配置，配置ID:', pricingId);

                // 现在都是可编辑的输入框，所以只需要给出提示
                showMessage('直接在表格中修改相应字段即可，修改后点击“保存所有配置”按钮即可保存');
            },


            // 取消删除地区定价配置
            cancelDeleteAreaPricing: function (pricingId) {
                const row = document.querySelector(`tr[data-pricing-id="${pricingId}"]`);
                if (row) {
                    // 移除删除标记
                    row.classList.remove('marked-for-deletion');
                    row.style.backgroundColor = '';
                    row.style.opacity = '';

                    // 恢复输入框
                    const inputs = row.querySelectorAll('input, select');
                    inputs.forEach(input => {
                        input.removeAttribute('disabled');
                    });

                    // 恢复删除按钮
                    const deleteButton = row.querySelector('.btn-danger');
                    if (deleteButton) {
                        deleteButton.innerHTML = '<i class="icon-delete"></i> 删除';
                        deleteButton.title = '删除配置';
                        deleteButton.onclick = function () {
                            window.V3StrategyEditModal.deleteAreaPricing(pricingId);
                        };
                    }

                    showMessage('已取消删除标记');
                }
            },

            // 打开重量规则编辑器
            openWeightRuleEditor: function (ruleId = null) {
                const isEdit = ruleId !== null;
                const title = isEdit ? '编辑重量区间规则' : '添加重量区间规则';

                console.log(`📝 开始${title}，ruleId:`, ruleId);

                // 检查是否有选中的策略
                if (!strategy || !strategy.id) {
                    console.error('❌ 未选中策略');
                    showMessage('请先选择一个策略', true);
                    return;
                }

                console.log('📊 当前策略:', strategy);

                // 获取当前策略的定价配置ID
                let defaultPricingId = null;

                // 方法1: 从已加载的地区定价表格中获取
                const areaPricingRows = document.querySelectorAll('#area-pricing-list tr[data-pricing-id]');
                if (areaPricingRows.length > 0) {
                    defaultPricingId = areaPricingRows[0].getAttribute('data-pricing-id');
                    console.log('📊 从表格获取到pricingId:', defaultPricingId);
                }

                // 方法2: 如果表格中没有，尝试从策略对象中获取
                if (!defaultPricingId && strategy.areaPricingConfigs && strategy.areaPricingConfigs.length > 0) {
                    defaultPricingId = strategy.areaPricingConfigs[0].id;
                    console.log('📊 从策略对象获取到pricingId:', defaultPricingId);
                }

                // 方法3: 尝试从全局状态中获取
                if (!defaultPricingId && state.selectedStrategyAreas && state.selectedStrategyAreas.length > 0) {
                    const firstArea = state.selectedStrategyAreas[0];
                    if (firstArea.pricingId) {
                        defaultPricingId = firstArea.pricingId;
                        console.log('📊 从全局状态获取到pricingId:', defaultPricingId);
                    }
                }

                if (!defaultPricingId) {
                    console.error('❌ 未找到定价配置ID');
                    showMessage('📝 请先添加地区定价配置，然后再添加重量规则', true);
                    return;
                }

                console.log(`✅ 最终使用的pricingId: ${defaultPricingId}`);

                // 简单的prompt输入，实际项目中可以做成弹框
                const upperBound = prompt('请输入重量上限（kg）:');
                if (upperBound === null) return;

                const freight = prompt('请输入区间费用（元）:');
                if (freight === null) return;

                // 构建要保存的数据
                const ruleData = {
                    id: ruleId,
                    strategyId: strategy.id,
                    pricingId: parseInt(defaultPricingId), // 确保转换为整数
                    upperBound: parseFloat(upperBound),
                    freight: parseFloat(freight)
                };

                console.log('📦 准备保存的重量规则数据:', ruleData);

                // 保存重量规则
                this.saveWeightRule(ruleData);
            },

            // 保存重量规则
            saveWeightRule: async function (ruleData) {
                try {
                    // 详细的参数验证和日志记录
                    console.log('💾 开始保存重量规则，参数:', ruleData);

                    // 验证必要参数
                    if (!ruleData.strategyId) {
                        throw new Error('策略ID不能为空');
                    }
                    if (!ruleData.pricingId) {
                        throw new Error('定价配置ID不能为空');
                    }
                    if (!ruleData.upperBound || ruleData.upperBound < 0) {
                        throw new Error('重量上限不能为负数');
                    }
                    if (!ruleData.freight || ruleData.freight < 0) {
                        throw new Error('区间费用不能为负数');
                    }

                    // 判断是新增还是更新
                    const isUpdate = ruleData.id !== null && ruleData.id !== undefined;
                    const apiUrl = isUpdate ? '/weight-segment-rule/update' : '/weight-segment-rule/add';

                    console.log(`📡 发送请求到: ${apiUrl}`);
                    console.log('📦 请求数据:', JSON.stringify(ruleData, null, 2));

                    const response = await fetch(apiUrl, {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json;charset=UTF-8'
                        },
                        body: JSON.stringify(ruleData)
                    });

                    const result = await response.json();
                    console.log('📨 服务器响应:', result);

                    if (result.code === 0) {
                        showMessage('重量规则保存成功');
                        console.log('✅ 重量规则保存成功');

                        // 标记已单独保存的行
                        const row = document.querySelector(`#weight-rules-list tr[data-rule-id="${ruleData.tempId || ruleData.id}"]`);
                        if (row) row.classList.add('saved');

                        // 重新加载数据
                        const weightRulesData = await loadStrategyWeightRulesData(strategy.id);
                        renderWeightRulesTable(weightRulesData);
                    } else {
                        throw new Error(result.msg || '保存失败');
                    }
                } catch (error) {
                    console.error('❌ 保存重量规则失败:', error);
                    showMessage('❌ 保存失败: ' + error.message, true);
                }
            },

            /**
             * 保存地区定价配置 - V2版本（简化结构）
             * <pre>
             * 根据需求一调整的新版本保存方法，采用简化的嵌套参数结构。
             * 主要变更：
             * 1. 将新增、修改、删除的配置数据整合到统一列表中
             * 2. 通过ID是否为null判断操作类型：null=新增，非null=更新
             * 3. 数据库中存在但请求中不存在的记录将被删除
             * 4. 采用直接嵌套结构，不再使用临时ID关联
             * </pre>
             */
            saveAreaPricingConfigV2: async function (strategyId) {
                // 获取当前策略ID
                const currentStrategyId = strategyId ||
                    (window.V3StrategyEditModal && window.V3StrategyEditModal.currentStrategy ? window.V3StrategyEditModal.currentStrategy.id : null) ||
                    (state.selectedStrategy ? state.selectedStrategy.id : null);

                if (!currentStrategyId) {
                    showMessage('未找到当前策略ID，请重新选择策略', true);
                    return;
                }

                console.log('📦 V2版本保存地区定价配置，策略ID:', currentStrategyId);

                try {
                    /**
                     * 【修复关键问题】构建简化的嵌套结构数据
                     * 根据需求：传递全部数据(暂存区+页面数据)，只需排除删除的数据
                     * - weightRuleList: 重量规则列表
                     *   - 每个重量规则包含 areaConfigList: 区域配置列表
                     *   - ID存在表示更新，ID为null表示新增
                     *   - 数据库中存在但请求中不包含的将被删除
                     */
                    const weightRuleList = [];

                    // 【关键修复】步骤1：收集ALL数据源（DOM + 暂存数据）
                    console.log('🔍 开始收集所有数据源...');

                    // 1.1: 从DOM收集现有数据（页面数据）
                    const areaConfigMap = new Map();

                    // 【修复问题三】正确收集所有类型的区域配置行（现有的 + 暂存的）
                    const existingRows = document.querySelectorAll('#area-pricing-list tr[data-pricing-id]'); // 现有的
                    const pendingRows = document.querySelectorAll('#area-pricing-list tr[data-temp-id]'); // 暂存的
                    const allAreaConfigRows = [...existingRows, ...pendingRows];

                    console.log('📊 DOM中找到现有区域配置行数:', existingRows.length);
                    console.log('📊 DOM中找到暂存区域配置行数:', pendingRows.length);
                    console.log('📊 DOM中找到总区域配置行数:', allAreaConfigRows.length);

                    // 统计标记删除的数据数量
                    const deletedExistingRows = document.querySelectorAll('#area-pricing-list tr[data-pricing-id].marked-for-deletion');
                    const deletedPendingRows = document.querySelectorAll('#area-pricing-list tr[data-temp-id].marked-for-deletion');
                    console.log('🗑️ 检测到标记删除的现有配置数量:', deletedExistingRows.length);
                    console.log('🗑️ 检测到标记删除的暂存配置数量:', deletedPendingRows.length);

                    // 【修复问题三】处理所有类型的区域配置行
                    for (const row of allAreaConfigRows) {
                        // 获取行的标识符（可能是 pricingId 或 tempId）
                        const pricingId = row.dataset.pricingId ? parseInt(row.dataset.pricingId) : null;
                        const tempId = row.dataset.tempId || null;
                        const rowId = pricingId || tempId;

                        if (!rowId) {
                            console.warn('⚠️ 跳过无效行（缺少ID）:', row);
                            continue;
                        }

                        // 跳过标记删除的配置
                        const isMarkedForDeletion = row.classList.contains('marked-for-deletion');
                        if (isMarkedForDeletion) {
                            console.log(`⏭️ 跳过标记删除的配置: ${rowId}`);
                            continue;
                        }

                        // 使用专门的函数构建区域配置对象
                        const areaConfig = this.buildAreaConfigFromRowUnified(row, currentStrategyId);
                        if (areaConfig) {
                            areaConfigMap.set(rowId, areaConfig);
                            console.log(`✅ 收集DOM区域配置: ${areaConfig.name} (ID: ${rowId}, 类型: ${typeof rowId})`);
                        }
                    }

                    // 1.2: 【关键修复】从暂存数据收集新增配置（暂存区数据）
                    if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.size > 0) {
                        console.log('📋 收集暂存区数据，数量:', window.pendingNewAreaConfigs.size);
                        for (const [tempId, config] of window.pendingNewAreaConfigs) {
                            // 检查是否与DOM数据重复（避免重复发送）
                            let isDuplicate = false;
                            for (const [existingId, existingConfig] of areaConfigMap) {
                                if (existingConfig.name === config.name &&
                                    JSON.stringify(existingConfig.selectedAreaIds?.sort()) === JSON.stringify(config.selectedAreaIds?.sort())) {
                                    isDuplicate = true;
                                    console.log('⚠️ 跳过重复的暂存配置:', config.name);
                                    break;
                                }
                            }

                            if (!isDuplicate) {
                                // 为暂存数据分配负数临时ID以区分新增
                                const stagingAreaConfig = {
                                    id: null, // 新增配置
                                    strategyId: currentStrategyId,
                                    name: config.name || '新增配置',
                                    description: config.description || '默认描述',
                                    firstWeightKg: config.firstWeightKg || 0,
                                    firstWeightFee: config.firstWeightFee || 0,
                                    additionalWeightKg: config.additionalWeightKg || 0,
                                    additionalWeightFee: config.additionalWeightFee || 0,
                                    volumetricWeightRatio: config.volumetricWeightRatio || 0,
                                    selectedAreaIds: config.selectedAreaIds || [],
                                    operator: 'admin'
                                };
                                areaConfigMap.set(tempId, stagingAreaConfig);
                                console.log(`✅ 收集暂存区域配置: ${stagingAreaConfig.name} (临时ID: ${tempId})`);
                            }
                        }
                    }

                    console.log('📋 总共收集到的区域配置数量:', areaConfigMap.size);

                    // 步骤2：处理重量规则及其关联的区域配置
                    const weightRuleRows = document.querySelectorAll('#weight-rules-list tr[data-rule-id]');

                    // 【修复问题三】上面已经统一处理了所有类型的行，无需重复处理

                    console.log('📋 收集到的区域配置映射:', areaConfigMap);

                    for (const row of weightRuleRows) {
                        const ruleId = row.dataset.ruleId;
                        if (!ruleId || ruleId === 'undefined') continue;

                        // 跳过已标记删除的规则
                        if (row.classList.contains('marked-for-deletion')) continue;

                        // 获取重量规则基础数据
                        const upperBoundInput = row.querySelector('input[data-field="upperBound"]');
                        const freightInput = row.querySelector('input[data-field="freight"]');
                        const pricingSelect = row.querySelector('select[data-field="pricingId"]');

                        if (!upperBoundInput || !freightInput) {
                            console.warn('⚠️ 跳过无效的重量规则行，缺少必要输入框:', ruleId);
                            continue;
                        }

                        // 【修复问题一】强制触发输入框的值更新，确保获取用户修改后的最新值
                        // 通过触发 change 事件确保内部状态同步
                        if (upperBoundInput.value !== upperBoundInput.getAttribute('value')) {
                            upperBoundInput.dispatchEvent(new Event('change', { bubbles: true }));
                        }
                        if (freightInput.value !== freightInput.getAttribute('value')) {
                            freightInput.dispatchEvent(new Event('change', { bubbles: true }));
                        }

                        // 获取最新的输入值
                        const upperBoundValue = upperBoundInput.value.trim();
                        const freightValue = freightInput.value.trim();

                        console.log(`🔍 读取重量规则数据 - ruleId: ${ruleId}, upperBound: "${upperBoundValue}", freight: "${freightValue}"`);

                        // 确保非空值的处理
                        const upperBound = upperBoundValue === '' ? 0 : parseFloat(upperBoundValue);
                        const freight = freightValue === '' ? 0 : parseFloat(freightValue);

                        if (isNaN(upperBound) || isNaN(freight)) {
                            console.warn('⚠️ 跳过无效的数值输入:', {ruleId, upperBoundValue, freightValue, upperBound, freight});
                            continue;
                        }

                        if (upperBound < 0 || freight < 0) {
                            console.warn('⚠️ 跳过负值输入:', {ruleId, upperBound, freight});
                            continue;
                        }

                        // 获取该重量规则关联的区域配置ID
                        const pricingIdValue = pricingSelect ? pricingSelect.value : null;

                        // 【修复问题二】正确处理临时ID(字符串)和正式ID(数字)
                        let pricingId = null;
                        if (pricingIdValue) {
                            if (pricingIdValue.toString().startsWith('temp_')) {
                                // 临时ID保持为字符串
                                pricingId = pricingIdValue;
                            } else if (!isNaN(parseInt(pricingIdValue))) {
                                // 正式ID转换为数字
                                pricingId = parseInt(pricingIdValue);
                            } else {
                                // 其他情况保持原值
                                pricingId = pricingIdValue;
                            }
                        }

                        console.log(`🔍 重量规则 ${ruleId} 关联的区域配置ID: ${pricingId} (类型: ${typeof pricingId})`);

                        // [关键修复] 只有当重量规则有关联的区域配置时才添加到列表
                        if (pricingId && areaConfigMap.has(pricingId)) {
                            // 从映射中获取区域配置
                            const areaConfig = areaConfigMap.get(pricingId);
                            if (areaConfig && areaConfig.selectedAreaIds && areaConfig.selectedAreaIds.length > 0) {
                                // 构建重量规则基础数据
                                const weightRule = {
                                    id: parseInt(ruleId) > 0 ? parseInt(ruleId) : null,
                                    strategyId: currentStrategyId,
                                    pricingId: null, // V2版本不再依赖pricingId关联，由后端自动处理
                                    upperBound: upperBound,
                                    freight: freight,
                                    operator: 'admin',
                                    areaConfigList: [areaConfig]
                                };

                                weightRuleList.push(weightRule);
                                console.log('✅ 添加有效的重量规则:', ruleId, '->', pricingId, areaConfig.name);
                            } else {
                                console.log('⚠️ 跳过无效的区域配置，重量规则ID:', ruleId, 'pricingId:', pricingId);
                            }
                        } else {
                            console.log('⚠️ 跳过没有关联区域配置的重量规则，ruleId:', ruleId, 'pricingId:', pricingId);
                        }
                    }

                    // 【修复问题】不再自动为独立区域配置创建默认重量规则
                    // 根据需求：删除重量区间配置数据后，只传递页面上显示的信息，不包含删除的信息
                    // 不应该自动为失去关联的区域配置创建默认重量规则，这会导致传递不应该存在的数据
                    // 【关键修复】当没有重量规则时，为独立的区域配置创建默认重量规则以保持数据
                    if (weightRuleList.length === 0) {
                        console.log('📋 检测到没有重量规则，为独立区域配置创建默认重量规则以保持地区配置');
                        console.log('📋 开始处理 areaConfigMap 中的所有配置，数量:', areaConfigMap.size);

                        // 【修复】直接处理 areaConfigMap 中的所有区域配置（包括DOM和暂存区的）
                        for (const [configId, areaConfig] of areaConfigMap) {
                            if (areaConfig && areaConfig.selectedAreaIds && areaConfig.selectedAreaIds.length > 0) {
                                // 为每个区域配置创建一个默认的重量规则
                                const defaultWeightRule = {
                                    id: null, // 新增规则
                                    strategyId: currentStrategyId,
                                    pricingId: null,
                                    upperBound: 0.0, // 默认重量上限
                                    freight: 0.0, // 默认费用
                                    operator: 'admin'
                                };

                                // 将默认重量规则添加到区域配置中
                                areaConfig.weightRuleList = [defaultWeightRule];
                                console.log('✅ 为区域配置创建默认重量规则:', configId, areaConfig.name);
                            }
                        }

                        console.log('⚠️ 修复后重量规则数量:', weightRuleList.length);
                    } else {
                        console.log('📝 存在重量规则，只传递页面上实际存在且有效的重量规则配置');
                    }

                    // 记录处理过的区域配置（用于日志）
                    const processedAreaConfigs = new Set();
                    weightRuleList.forEach(rule => {
                        rule.areaConfigList.forEach(config => {
                            if (config.id) {
                                processedAreaConfigs.add(config.id);
                            }
                        });
                    });
                    console.log('📊 已处理的区域配置ID:', Array.from(processedAreaConfigs));

                    // 步骤3：【修复问题二】正确处理暂存的区域配置
                    if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.size > 0) {
                        console.log('🔄 处理暂存的区域配置...');

                        // 检查是否有页面上显示的重量规则配置行
                        const visibleWeightRuleRows = document.querySelectorAll('#weight-rules-list tr[data-rule-id]:not(.marked-for-deletion)');
                        console.log(`📋 检查页面可见重量规则：${visibleWeightRuleRows.length}个`);

                        // 【修复问题二】为所有暂存区域配置创建重量规则，确保数据不丢失
                        // 修复前的问题：暂存的地区配置没有对应的重量规则，导致数据无法传递到后端
                        console.log('✅ 【修复问题二】为暂存区域配置创建重量规则，确保数据完整传递');

                        for (const [tempId, areaConfig] of areaConfigMap) {
                            // 只处理暂存配置（字符串类型的tempId）
                            if (typeof tempId === 'string' && tempId.startsWith('temp_')) {
                                // 检查是否已经有重量规则关联到这个配置
                                const hasExistingRule = weightRuleList.some(rule =>
                                    rule.areaConfigList &&
                                    rule.areaConfigList.some(config => config.tempId === tempId ||
                                        (config.selectedAreaIds && areaConfig.selectedAreaIds &&
                                         JSON.stringify(config.selectedAreaIds.sort()) === JSON.stringify(areaConfig.selectedAreaIds.sort()))
                                    )
                                );

                                if (!hasExistingRule && areaConfig.selectedAreaIds && areaConfig.selectedAreaIds.length > 0) {
                                    // 为暂存配置创建默认重量规则
                                    const defaultWeightRule = {
                                        id: null, // 新增规则
                                        strategyId: currentStrategyId,
                                        pricingId: null,
                                        upperBound: 0.0, // 默认重量上限
                                        freight: 0.0, // 默认费用
                                        operator: 'admin',
                                        areaConfigList: [areaConfig]
                                    };

                                    weightRuleList.push(defaultWeightRule);
                                    console.log('✅ 为暂存区域配置创建默认重量规则:', tempId, areaConfig.name);
                                }
                            }
                        }

                        console.log('📝 暂存区域配置处理完成，确保所有数据都能传递到后端');
                    }

                    // 【修复问题四】正确处理删除重量规则后的地区配置保留问题
                    // 区分两种情况：
                    // 1. 如果没有任何重量规则（全部被删除），为所有地区配置创建默认规则
                    // 2. 如果还有其他重量规则，就不创建额外的默认规则，尊重用户的删除意图

                    // 检查是否所有重量规则都被删除了
                    const hasAnyWeightRule = weightRuleList.length > 0;

                    if (!hasAnyWeightRule) {
                        // 情况1：所有重量规则都被删除，为所有地区配置创建默认规则以保持数据
                        console.log('📝 检测到所有重量规则都被删除，为所有地区配置创建默认规则以保持数据');

                        for (const [configId, areaConfig] of areaConfigMap) {
                            if (areaConfig && areaConfig.selectedAreaIds && areaConfig.selectedAreaIds.length > 0) {
                                const preserveWeightRule = {
                                    id: null, // 新增规则
                                    strategyId: currentStrategyId,
                                    pricingId: null,
                                    upperBound: 0.0, // 默认重量上限
                                    freight: 0.0, // 默认费用
                                    operator: 'admin'
                                };

                                // 将默认重量规则添加到区域配置中
                                areaConfig.weightRuleList = [preserveWeightRule];
                                console.log(`✅ 为地区配置创建默认重量规则: ${areaConfig.name}`);
                            }
                        }
                    } else {
                        // 情况2：还有其他重量规则存在，保留所有地区配置，为失去关联的地区配置创建默认重量规则
                        console.log('📝 检测到还有其他重量规则存在，但需要保留所有地区配置');
                        console.log(`📋 当前有效重量规则数量: ${weightRuleList.length}`);

                        // 统计哪些地区配置失去了关联
                        const processedAreaConfigs = new Set();
                        weightRuleList.forEach(rule => {
                            rule.areaConfigList.forEach(config => {
                                if (config.id) processedAreaConfigs.add(config.id);
                                if (config.tempId) processedAreaConfigs.add(config.tempId);
                            });
                        });

                        const orphanedConfigs = [];
                        for (const [configId, areaConfig] of areaConfigMap) {
                            if (!processedAreaConfigs.has(configId) && areaConfig.selectedAreaIds && areaConfig.selectedAreaIds.length > 0) {
                                orphanedConfigs.push({id: configId, config: areaConfig});
                            }
                        }

                        if (orphanedConfigs.length > 0) {
                            console.log(`🛡️ 发现 ${orphanedConfigs.length} 个失去关联的地区配置，为它们创建默认重量规则以保持数据:`);

                            orphanedConfigs.forEach(({id, config}) => {
                                console.log(`  - ${config.name} (ID: ${id})`);

                                // 为这个地区配置创建一个默认的重量规则以保持数据
                                const preserveWeightRule = {
                                    id: null, // 新增规则
                                    strategyId: currentStrategyId,
                                    pricingId: null,
                                    upperBound: 0.0, // 默认重量上限
                                    freight: 0.0, // 默认费用
                                    operator: 'admin'
                                };

                                // 将默认重量规则添加到区域配置中
                                config.weightRuleList = [preserveWeightRule];
                                console.log(`✅ 为失去关联的地区配置创建默认重量规则: ${config.name}`);
                            });

                            console.log(`🛡️ 已为 ${orphanedConfigs.length} 个地区配置创建保护性重量规则，确保地区配置不会丢失`);
                        } else {
                            console.log('✅ 所有地区配置都有对应的重量规则关联，无需额外处理');
                        }
                    }

                    // 检查是否有数据需要保存
                    // if (weightRuleList.length === 0) {
                    //     showMessage('没有需要保存的配置数据', true);
                    //     return;
                    // }

                    // 构建请求数据 - 修正数据结构：区域配置包含重量规则
                    const areaConfigList = [];

                    // 收集所有区域配置
                    for (const [configId, areaConfig] of areaConfigMap) {
                        if (areaConfig && areaConfig.selectedAreaIds && areaConfig.selectedAreaIds.length > 0) {
                            // 为每个区域配置找到对应的重量规则
                            const weightRulesForThisArea = weightRuleList.filter(rule =>
                                rule.areaConfigList &&
                                rule.areaConfigList.some(config =>
                                    config.id === areaConfig.id || config.tempId === configId
                                )
                            );

                            // 创建正确的区域配置对象，包含重量规则列表
                            const correctedAreaConfig = {
                                ...areaConfig,
                                weightRuleList: weightRulesForThisArea.map(rule => ({
                                    id: rule.id,
                                    strategyId: rule.strategyId,
                                    pricingId: rule.pricingId,
                                    upperBound: rule.upperBound,
                                    freight: rule.freight,
                                    operator: rule.operator
                                }))
                            };

                            areaConfigList.push(correctedAreaConfig);
                        }
                    }

                    const requestData = {
                        strategyId: currentStrategyId,
                        areaConfigList: areaConfigList,
                        operator: 'admin'
                    };

                    console.log('📦 准备发送V2版本数据（修正后结构）:', requestData);

                    // 调用V2版本的API
                    const result = await unifiedApiCall(
                        'saveAllConfigV2',
                        '/strategy-area-pricing/save-all-config-v2',
                        requestData
                    );

                    console.log('📨 V2版本接口响应:', result);

                    if (result.code === 0) {
                        showMessage('🎉 配置保存成功！', 'success');

                        // 清除修改标记
                        document.querySelectorAll('.table-input.modified').forEach(input => {
                            input.classList.remove('modified');
                        });

                        // 清除临时数据
                        window.pendingNewAreaConfigs = null;
                        window.pendingAreaChanges = null;
                        window.pendingWeightRules = null;
                        window.pendingAreaPricingDeletions = null;

                        // 刷新数据显示
                        setTimeout(async () => {
                            try {
                                const unifiedData = await loadUnifiedStrategyData(currentStrategyId);
                                renderAreaPricingTable(unifiedData.areaPricing);
                                renderWeightRulesTable(unifiedData.weightRules);
                                console.log('✅ 数据刷新完成');
                            } catch (error) {
                                console.error('❌ 数据刷新失败:', error);
                            }
                        }, 500);
                    } else {
                        showMessage(`❌ 保存失败：${result.msg}`, true);
                    }

                } catch (error) {
                    console.error('❌ V2版本保存配置失败:', error);
                    showMessage('保存失败: ' + error.message, true);
                }
            },

            // 从DOM行构建区域配置对象
            buildAreaConfigFromRow: function (row, strategyId) {
                if (!row || !row.dataset.pricingId) {
                    console.warn('⚠️ 无效的行数据');
                    return null;
                }

                // 【修复关键问题】检查行是否被标记为删除，如果是则不构建配置对象
                if (row.classList.contains('marked-for-deletion')) {
                    console.log('⏭️ 跳过构建标记删除的配置:', row.dataset.pricingId);
                    return null;
                }

                const pricingId = parseInt(row.dataset.pricingId);

                try {
                    // 从行中提取所有输入字段的值
                    const nameInput = row.querySelector('input[data-field="name"]');
                    const firstWeightKgInput = row.querySelector('input[data-field="firstWeightKg"]');
                    const firstWeightFeeInput = row.querySelector('input[data-field="firstWeightFee"]');
                    const additionalWeightKgInput = row.querySelector('input[data-field="additionalWeightKg"]');
                    const additionalWeightFeeInput = row.querySelector('input[data-field="additionalWeightFee"]');
                    const volumetricWeightRatioInput = row.querySelector('input[data-field="volumetricWeightRatio"]');
                    const descriptionInput = row.querySelector('input[data-field="description"]');

                    // 获取选中的地区ID列表
                    const selectedAreaIds = this.getSelectedAreaIds(pricingId);

                    // 构建区域配置对象
                    const areaConfig = {
                        id: pricingId > 0 ? pricingId : null, // 如果是正数ID则为更新，否则为新增
                        strategyId: strategyId,
                        name: nameInput ? (nameInput.value || '未命名配置') : '未命名配置',
                        description: descriptionInput ? (descriptionInput.value || '默认描述') : '默认描述',
                        firstWeightKg: firstWeightKgInput ? (parseFloat(firstWeightKgInput.value) || 0.0) : 0.0,
                        firstWeightFee: firstWeightFeeInput ? (parseFloat(firstWeightFeeInput.value) || 0.0) : 0.0,
                        additionalWeightKg: additionalWeightKgInput ? (parseFloat(additionalWeightKgInput.value) || 0.0) : 0.0,
                        additionalWeightFee: additionalWeightFeeInput ? (parseFloat(additionalWeightFeeInput.value) || 0.0) : 0.0,
                        volumetricWeightRatio: volumetricWeightRatioInput ? (parseFloat(volumetricWeightRatioInput.value) || 0.0) : 0.0,
                        status: 1, // 默认启用状态
                        selectedAreaIds: selectedAreaIds || [],
                        operator: 'admin',
                        confirmed: true
                    };

                    console.log('🏗️ 从行构建区域配置:', areaConfig);
                    return areaConfig;

                } catch (error) {
                    console.error('❌ 从行构建区域配置失败:', error);
                    return null;
                }
            },

            /**
             * 【修复问题三】统一处理现有和暂存区域配置行的构建函数
             * @param {HTMLElement} row - DOM行元素
             * @param {number} strategyId - 策略ID
             * @returns {Object|null} - 区域配置对象
             */
            buildAreaConfigFromRowUnified: function (row, strategyId) {
                if (!row) {
                    console.warn('⚠️ 无效的行数据');
                    return null;
                }

                // 检查行是否被标记为删除
                if (row.classList.contains('marked-for-deletion')) {
                    console.log('⏭️ 跳过构建标记删除的配置:', row.dataset.pricingId || row.dataset.tempId);
                    return null;
                }

                // 获取行的标识符
                const pricingId = row.dataset.pricingId ? parseInt(row.dataset.pricingId) : null;
                const tempId = row.dataset.tempId || null;
                const rowId = pricingId || tempId;

                if (!rowId) {
                    console.warn('⚠️ 行缺少有效标识符');
                    return null;
                }

                try {
                    // 从行中提取所有输入字段的值
                    const nameInput = row.querySelector('input[data-field="name"]') || row.querySelector('input[data-temp-id="' + tempId + '"][data-field="name"]');
                    const firstWeightKgInput = row.querySelector('input[data-field="firstWeightKg"]') || row.querySelector('input[data-temp-id="' + tempId + '"][data-field="firstWeightKg"]');
                    const firstWeightFeeInput = row.querySelector('input[data-field="firstWeightFee"]') || row.querySelector('input[data-temp-id="' + tempId + '"][data-field="firstWeightFee"]');
                    const additionalWeightKgInput = row.querySelector('input[data-field="additionalWeightKg"]') || row.querySelector('input[data-temp-id="' + tempId + '"][data-field="additionalWeightKg"]');
                    const additionalWeightFeeInput = row.querySelector('input[data-field="additionalWeightFee"]') || row.querySelector('input[data-temp-id="' + tempId + '"][data-field="additionalWeightFee"]');
                    const volumetricWeightRatioInput = row.querySelector('input[data-field="volumetricWeightRatio"]') || row.querySelector('input[data-temp-id="' + tempId + '"][data-field="volumetricWeightRatio"]');
                    const descriptionInput = row.querySelector('input[data-field="description"]') || row.querySelector('input[data-temp-id="' + tempId + '"][data-field="description"]');

                    // 获取选中的地区ID列表
                    let selectedAreaIds = [];
                    if (pricingId) {
                        // 现有配置：使用现有的getSelectedAreaIds方法
                        selectedAreaIds = this.getSelectedAreaIds(pricingId) || [];
                    } else if (tempId) {
                        // 暂存配置：从暂存数据或DOM获取
                        if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.has(tempId)) {
                            selectedAreaIds = window.pendingNewAreaConfigs.get(tempId).selectedAreaIds || [];
                        } else {
                            // 从 DOM 元素获取
                            const areaTags = row.querySelectorAll('.area-tag[data-area-id]');
                            selectedAreaIds = Array.from(areaTags).map(tag => parseInt(tag.getAttribute('data-area-id'))).filter(id => !isNaN(id));
                        }
                    }

                    // 构建区域配置对象
                    const areaConfig = {
                        id: pricingId || null, // 如果是正数ID则为更新，否则为新增
                        tempId: tempId || null, // 保留临时ID用于跟踪
                        strategyId: strategyId,
                        name: nameInput ? (nameInput.value || '未命名配置') : '未命名配置',
                        description: descriptionInput ? (descriptionInput.value || '默认描述') : '默认描述',
                        firstWeightKg: firstWeightKgInput ? (parseFloat(firstWeightKgInput.value) || 0.0) : 0.0,
                        firstWeightFee: firstWeightFeeInput ? (parseFloat(firstWeightFeeInput.value) || 0.0) : 0.0,
                        additionalWeightKg: additionalWeightKgInput ? (parseFloat(additionalWeightKgInput.value) || 0.0) : 0.0,
                        additionalWeightFee: additionalWeightFeeInput ? (parseFloat(additionalWeightFeeInput.value) || 0.0) : 0.0,
                        volumetricWeightRatio: volumetricWeightRatioInput ? (parseFloat(volumetricWeightRatioInput.value) || 0.0) : 0.0,
                        status: 1, // 默认启用状态
                        selectedAreaIds: selectedAreaIds,
                        operator: 'admin',
                        confirmed: true
                    };

                    console.log(`🏠 统一构建区域配置 (${tempId ? '暂存' : '现有'}):`, areaConfig);
                    return areaConfig;

                } catch (error) {
                    console.error('❌ 统一构建区域配置失败:', error);
                    return null;
                }
            },

            // 获取指定区域配置的选中地区ID列表
            getSelectedAreaIds: function (pricingId) {
                console.log('🔍 获取地区ID列表, 配置ID:', pricingId);

                // 尝试从缓存中获取
                if (window.areaPricingAreaMappingCache && window.areaPricingAreaMappingCache[pricingId]) {
                    console.log('📋 从缓存获取地区ID:', window.areaPricingAreaMappingCache[pricingId]);
                    return window.areaPricingAreaMappingCache[pricingId];
                }

                // 尝试从DOM元素的data属性中获取
                const row = document.querySelector(`#area-pricing-list tr[data-pricing-id="${pricingId}"]`);
                if (row && row.dataset.selectedAreaIds) {
                    try {
                        const areaIds = JSON.parse(row.dataset.selectedAreaIds);
                        console.log('📋 从DOM data属性获取地区ID:', areaIds);
                        return areaIds;
                    } catch (e) {
                        console.warn('解析选中地区ID失败:', e);
                    }
                }

                // 尝试从暂存的地区变更中获取
                if (window.pendingAreaChanges && window.pendingAreaChanges.has(pricingId)) {
                    const areaIds = window.pendingAreaChanges.get(pricingId).selectedAreaIds;
                    console.log('📋 从暂存变更获取地区ID:', areaIds);
                    return areaIds || [];
                }

                // 尝试从暂存的新增配置中获取
                if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.has(pricingId)) {
                    const areaIds = window.pendingNewAreaConfigs.get(pricingId).selectedAreaIds;
                    console.log('📋 从暂存新增配置获取地区ID:', areaIds);
                    return areaIds || [];
                }

                // 最后尝试从地区标签中解析
                if (row) {
                    const areaTags = row.querySelectorAll('.area-tag[data-area-id]');
                    if (areaTags.length > 0) {
                        const areaIds = Array.from(areaTags).map(tag => parseInt(tag.getAttribute('data-area-id'))).filter(id => !isNaN(id));
                        if (areaIds.length > 0) {
                            console.log('📋 从地区标签解析地区ID:', areaIds);
                            return areaIds;
                        }
                    }

                    // 【关键修复】如果地区标签没有data-area-id属性，尝试通过后端API获取
                    console.warn('🔍 地区标签缺少data-area-id，尝试通过后端API获取配置ID', pricingId, '的地区ID');
                    return this.getAreaIdsByPricingIdFromAPI(pricingId);
                }

                console.warn('⚠️ 未找到配置ID', pricingId, '对应的地区ID，返回空数组');
                return [];
            },

            // 【新增方法】通过后端API获取配置的地区ID列表
            getAreaIdsByPricingIdFromAPI: function(pricingId) {
                console.log('📡 通过API获取配置的地区ID, pricingId:', pricingId);

                // 同步调用，从全局策略数据中查找
                if (window.V3StrategyEditModal && window.V3StrategyEditModal.currentStrategy) {
                    const strategyId = window.V3StrategyEditModal.currentStrategy.id;

                    // 这里我们需要同步获取，所以从已加载的数据中查找
                    // 检查是否有已加载的地区配置数据
                    if (window.cachedStrategyAreaData && window.cachedStrategyAreaData[strategyId]) {
                        const config = window.cachedStrategyAreaData[strategyId].find(item => item.id == pricingId);
                        if (config && config.areaIds && config.areaIds.length > 0) {
                            console.log('📋 从缓存策略数据获取地区ID:', config.areaIds);
                            return config.areaIds;
                        }
                    }

                    // 如果缓存中没有，尝试发起同步请求获取
                    try {
                        console.log('📡 发起同步请求获取地区ID...');

                        const xhr = new XMLHttpRequest();
                        const url = `/freight/strategy-area-pricing/list`;
                        xhr.open('POST', url, false); // 同步请求
                        xhr.setRequestHeader('Content-Type', 'application/json;charset=UTF-8');

                        const requestData = { strategyId: strategyId };
                        xhr.send(JSON.stringify(requestData));

                        if (xhr.status === 200) {
                            const result = JSON.parse(xhr.responseText);
                            if (result.code === 0 && result.data) {
                                // 缓存数据供后续使用
                                if (!window.cachedStrategyAreaData) {
                                    window.cachedStrategyAreaData = {};
                                }
                                window.cachedStrategyAreaData[strategyId] = result.data;

                                // 查找指定配置的地区ID
                                const config = result.data.find(item => item.id == pricingId);
                                if (config && config.areaIds && config.areaIds.length > 0) {
                                    console.log('📋 从API同步获取地区ID:', config.areaIds);
                                    return config.areaIds;
                                }
                            }
                        }
                    } catch (error) {
                        console.error('❌ 同步获取地区ID失败:', error);
                    }
                }

                console.warn('⚠️ 无法通过API获取配置', pricingId, '的地区ID');
                return [];
            },

            // 保存地区定价配置
            saveAreaPricingConfig: async function (strategyId) {
                // 获取当前策略ID，优先使用参数，然后使用当前策略
                const currentStrategyId = strategyId ||
                    (window.V3StrategyEditModal && window.V3StrategyEditModal.currentStrategy ? window.V3StrategyEditModal.currentStrategy.id : null) ||
                    (state.selectedStrategy ? state.selectedStrategy.id : null);

                if (!currentStrategyId) {
                    showMessage('未找到当前策略ID，请重新选择策略', true);
                    return;
                }

                console.log('保存地区定价配置，策略ID:', currentStrategyId);

                // 声明全局变量
                let weightRuleDeletions = [];

                try {
                    // 首先检查并保存未保存的临时重量规则
                    const newWeightRuleElements = document.querySelectorAll('#weight-rules-list tr.new-weight-rule');
                    if (newWeightRuleElements.length > 0) {
                        console.log('发现未保存的临时重量规则:', newWeightRuleElements.length, '条');

                        for (const row of newWeightRuleElements) {
                            const tempId = row.getAttribute('data-rule-id');
                            if (tempId && parseInt(tempId) < 0) {
                                try {
                                    // 获取表单数据
                                    const pricingSelect = row.querySelector('select[data-field="pricingId"]');
                                    const upperBoundInput = row.querySelector('input[data-field="upperBound"]');
                                    const freightInput = row.querySelector('input[data-field="freight"]');

                                    // 数据验证
                                    if (!pricingSelect.value) {
                                        showMessage('请选择地区配置（重量规则）', true);
                                        return;
                                    }
                                    if (!upperBoundInput.value || parseFloat(upperBoundInput.value) < 0) {
                                        showMessage('请输入正确的重量上限', true);
                                        return;
                                    }
                                    if (!freightInput.value || parseFloat(freightInput.value) < 0) {
                                        showMessage('请输入正确的区间费用', true);
                                        return;
                                    }

                                    const ruleData = {
                                        strategyId: currentStrategyId,
                                        pricingId: parseInt(pricingSelect.value),
                                        upperBound: parseFloat(upperBoundInput.value),
                                        freight: parseFloat(freightInput.value),
                                        operator: 'admin'
                                    };

                                    // 保存临时规则
                                    // ========== 问题修复：使用统一API调用 ==========
                                    const result = await unifiedApiCall(
                                        'addWeightRule',
                                        '/weight-segment-rule/add',
                                        ruleData
                                    );
                                    // ========== 问题修复结束 ==========
                                    if (result.code !== 0) {
                                        throw new Error(result.msg || '保存临时规则失败');
                                    }

                                    console.log('临时重量规则保存成功:', tempId);
                                } catch (error) {
                                    console.error('保存临时重量规则失败:', error);
                                    showMessage('保存临时重量规则失败: ' + error.message, true);
                                    return;
                                }
                            }
                        }

                        // 重新加载重量规则表格
                        const weightRulesData = await loadStrategyWeightRulesData(currentStrategyId);
                        renderWeightRulesTable(weightRulesData);

                        showMessage('临时重量规则已全部保存');
                    }
                    // 收集所有需要保存的地区定价配置数据（不仅仅是修改过的）
                    const areaPricingRows = document.querySelectorAll('#area-pricing-list tr[data-pricing-id]');
                    const areaPricingUpdates = [];

                    // 收集地区定价表格中的所有行数据
                    areaPricingRows.forEach(row => {
                        const pricingId = row.dataset.pricingId;
                        if (!pricingId || pricingId === 'undefined') return;

                        // 从每一行的输入框中获取完整数据
                        const nameInput = row.querySelector('input[data-field="name"]');
                        const firstWeightKgInput = row.querySelector('input[data-field="firstWeightKg"]');
                        const firstWeightFeeInput = row.querySelector('input[data-field="firstWeightFee"]');
                        const additionalWeightKgInput = row.querySelector('input[data-field="additionalWeightKg"]');
                        const additionalWeightFeeInput = row.querySelector('input[data-field="additionalWeightFee"]');
                        const volumetricWeightRatioInput = row.querySelector('input[data-field="volumetricWeightRatio"]');
                        const descriptionInput = row.querySelector('input[data-field="description"]');

                        // 检查是否有任何修改
                        const hasModifications = row.querySelector('.table-input.modified') !== null;

                        if (hasModifications) {
                            // 构建完整的更新对象，包含所有必要的字段
                            const updateData = {
                                id: parseInt(pricingId),
                                // strategyId 由后端从数据库获取，不需要前端传递
                                name: nameInput ? (nameInput.value || '未命名配置') : '未命名配置',
                                description: descriptionInput ? (descriptionInput.value || '默认描述') : '默认描述',
                                firstWeightKg: firstWeightKgInput ? (parseFloat(firstWeightKgInput.value) || 1.0) : 1.0,
                                firstWeightFee: firstWeightFeeInput ? (parseFloat(firstWeightFeeInput.value) || 0.0) : 0.0,
                                additionalWeightKg: additionalWeightKgInput ? (parseFloat(additionalWeightKgInput.value) || 1.0) : 1.0,
                                additionalWeightFee: additionalWeightFeeInput ? (parseFloat(additionalWeightFeeInput.value)) : null,
                                volumetricWeightRatio: volumetricWeightRatioInput ? (parseFloat(volumetricWeightRatioInput.value)) : null,
                                status: 1, // 默认启用状态
                                operator: 'admin'
                            };

                            console.log('📄 清理更新数据:', updateData);
                            areaPricingUpdates.push(updateData);
                        }
                    });

                    // 收集重量规则更新数据（修复：确保包含所有必需字段）
                    const modifiedWeightInputs = document.querySelectorAll('#weight-rules-list .table-input.modified');
                    const weightRuleUpdates = [];

                    // 先收集所有有修改标记的行
                    const modifiedRuleIds = new Set();
                    modifiedWeightInputs.forEach(input => {
                        const id = input.dataset.id;
                        if (id && !isNaN(parseInt(id)) && parseInt(id) > 0) {
                            modifiedRuleIds.add(parseInt(id));
                        }
                    });

                    // 对每个修改过的规则，收集完整的数据（包括未修改的字段）
                    modifiedRuleIds.forEach(ruleId => {
                        const row = document.querySelector(`#weight-rules-list tr[data-rule-id="${ruleId}"]`);
                        if (row) {
                            // 从行中获取所有字段的值
                            const pricingSelect = row.querySelector('select[data-field="pricingId"]');
                            const upperBoundInput = row.querySelector('input[data-field="upperBound"]');
                            const freightInput = row.querySelector('input[data-field="freight"]');

                            // 确保所有必需字段都有值
                            if (pricingSelect && upperBoundInput && freightInput) {
                                const ruleData = {
                                    id: ruleId,
                                    strategyId: currentStrategyId,
                                    pricingId: parseInt(pricingSelect.value) || null,
                                    upperBound: parseFloat(upperBoundInput.value) || 0,
                                    freight: parseFloat(freightInput.value) || 0,
                                    operator: 'admin'
                                };

                                // 验证必需字段
                                if (ruleData.pricingId && ruleData.upperBound >= 0 && ruleData.freight >= 0) {
                                    weightRuleUpdates.push(ruleData);
                                    console.log('📌 收集重量规则数据:', ruleData);
                                } else {
                                    console.warn('⚠️ 跳过无效的重量规则数据:', ruleData);
                                }
                            }
                        }
                    });

                    // 收集新增的重量规则数据
                    const newWeightRules = [];
                    if (window.pendingWeightRules && window.pendingWeightRules.length > 0) {
                        window.pendingWeightRules.forEach(rule => {
                            newWeightRules.push({
                                tempId: rule.tempId || `temp_${Date.now()}_${Math.random()}`,
                                strategyId: currentStrategyId,
                                pricingId: rule.pricingId,
                                relatedAreaConfigTempId: rule.relatedAreaConfigTempId,
                                upperBound: rule.upperBound,
                                freight: rule.freight,
                                operator: 'admin'
                            });
                        });
                        console.log('📌 添加新增重量规则（pendingWeightRules）:', newWeightRules);
                    }

                    // 收集已确认的新增重量规则（从DOM中获取）
                    const confirmedNewRules = document.querySelectorAll('#weight-rules-list tr.confirmed-new-rule:not(.saved)');
                    confirmedNewRules.forEach(row => {
                        const tempId = row.getAttribute('data-rule-id');
                        if (tempId && parseInt(tempId) < 0) { // 负数ID表示新增规则
                            const pricingSelect = row.querySelector('select[data-field="pricingId"]');
                            const upperBoundInput = row.querySelector('input[data-field="upperBound"]');
                            const freightInput = row.querySelector('input[data-field="freight"]');

                            if (pricingSelect && upperBoundInput && freightInput) {
                                const ruleData = {
                                    tempId: tempId,
                                    strategyId: currentStrategyId,
                                    pricingId: parseInt(pricingSelect.value) || null,
                                    relatedAreaConfigTempId: pricingSelect.getAttribute('data-area-config-temp-id') || null,
                                    upperBound: parseFloat(upperBoundInput.value) || 0,
                                    freight: parseFloat(freightInput.value) || 0,
                                    operator: 'admin'
                                };

                                // 验证必需字段（对于新增重量规则，pricingId可以为空，通过relatedAreaConfigTempId关联）
                                if ((ruleData.pricingId && ruleData.upperBound >= 0 && ruleData.freight >= 0) ||
                                    (ruleData.relatedAreaConfigTempId && ruleData.upperBound >= 0 && ruleData.freight >= 0)) {
                                    newWeightRules.push(ruleData);
                                    console.log('📌 收集已确认的新增重量规则:', ruleData);
                                } else {
                                    console.warn('⚠️ 跳过无效的已确认重量规则数据:', ruleData);
                                }
                            }
                        }
                    });

                    // 收集标记删除的地区配置
                    const areaPricingDeletions = [];
                    if (window.pendingAreaPricingDeletions && window.pendingAreaPricingDeletions.length > 0) {
                        window.pendingAreaPricingDeletions.forEach(pricingId => {
                            areaPricingDeletions.push({
                                id: parseInt(pricingId),
                                operator: 'admin'
                            });
                        });
                    }

                    // 收集标记删除的重量规则
                    const markedForDeletion = document.querySelectorAll('#weight-rules-list tr.marked-for-deletion');
                    markedForDeletion.forEach(row => {
                        const ruleId = row.dataset.ruleId;
                        if (ruleId) {
                            weightRuleDeletions.push({
                                id: parseInt(ruleId),
                                operator: 'admin'
                            });
                        }
                    });

                    console.log('📌 收集到的删除重量规则:', weightRuleDeletions);

                    // 检查是否有需要保存的数据
                    const hasPendingNewAreas = window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.size > 0;
                    const hasPendingAreaChanges = window.pendingAreaChanges && window.pendingAreaChanges.size > 0;
                    const hasPendingWeightRules = window.pendingWeightRules && window.pendingWeightRules.length > 0;
                    const hasConfirmedNewWeightRules = document.querySelectorAll('#weight-rules-list tr.confirmed-new-rule').length > 0;
                    const hasNewWeightRules = newWeightRules.length > 0;
                    const hasWeightRuleDeletions = weightRuleDeletions.length > 0;
                    const hasAreaPricingDeletions = areaPricingDeletions.length > 0;

                    // 添加详细的调试信息
                    console.log('🔍 数据收集检查:');
                    console.log('  - areaPricingUpdates.length:', areaPricingUpdates.length);
                    console.log('  - weightRuleUpdates.length:', weightRuleUpdates.length);
                    console.log('  - newWeightRules.length:', newWeightRules.length);
                    console.log('  - hasPendingNewAreas:', hasPendingNewAreas, window.pendingNewAreaConfigs?.size);
                    console.log('  - hasPendingAreaChanges:', hasPendingAreaChanges, window.pendingAreaChanges?.size);
                    console.log('  - hasPendingWeightRules:', hasPendingWeightRules, window.pendingWeightRules?.length);
                    console.log('  - hasConfirmedNewWeightRules:', hasConfirmedNewWeightRules);
                    console.log('  - hasNewWeightRules:', hasNewWeightRules);
                    console.log('  - hasWeightRuleDeletions:', hasWeightRuleDeletions);
                    console.log('  - hasAreaPricingDeletions:', hasAreaPricingDeletions);
                    console.log('  - currentEditingPricingId:', window.V3StrategyEditModal?.currentEditingPricingId);

                    if (areaPricingUpdates.length === 0 && weightRuleUpdates.length === 0 &&
                        !hasPendingNewAreas && !hasPendingAreaChanges && !hasPendingWeightRules &&
                        !hasConfirmedNewWeightRules && !hasNewWeightRules && !hasWeightRuleDeletions && !hasAreaPricingDeletions &&
                        !(window.V3StrategyEditModal && window.V3StrategyEditModal.currentEditingPricingId)) {
                        showMessage('没有需要保存的修改');
                        return;
                    }

                    // 收集所有需要保存的数据
                    const configData = {
                        strategyId: currentStrategyId,
                        areaPricingUpdates: areaPricingUpdates,
                        areaPricingDeletions: areaPricingDeletions, // 添加地区配置删除
                        weightRuleUpdates: weightRuleUpdates,
                        weightRuleDeletions: weightRuleDeletions, // 添加删除操作
                        newWeightRules: newWeightRules, // 添加新增重量规则
                        operator: 'admin'
                    };

                    // 添加新增地区配置数据
                    if (hasPendingNewAreas) {
                        // 将 Map 对象转换为数组格式发送给后端
                        const newAreaConfigsArray = [];
                        window.pendingNewAreaConfigs.forEach((config, tempId) => {
                            newAreaConfigsArray.push({
                                tempId: tempId,
                                ...config
                            });
                        });
                        configData.newAreaConfigs = newAreaConfigsArray;
                        console.log('📌 添加新增地区配置:', newAreaConfigsArray);
                    }

                    // [修复] 添加地区映射变更数据 - 使用正确的字段名和数据结构
                    if (hasPendingAreaChanges) {
                        // 后端期望的是 areaUpdate 字段，而不是 areaChanges
                        const areaChanges = Array.from(window.pendingAreaChanges.values());
                        if (areaChanges.length > 0) {
                            // 只取第一个地区变更（同时只处理一个编辑）
                            const firstAreaChange = areaChanges[0];
                            configData.areaUpdate = {
                                pricingId: firstAreaChange.pricingId,
                                selectedAreaIds: firstAreaChange.selectedAreaIds,
                                operator: firstAreaChange.operator || 'admin'
                            };
                            console.log('📌 [修复] 添加地区映射变更（使用 areaUpdate 字段）:', configData.areaUpdate);
                        }
                    }

                    // 如果有地区更新信息（编辑地区情况），添加到配置中
                    if (window.V3StrategyEditModal && window.V3StrategyEditModal.currentEditingPricingId) {
                        // 获取当前选中的地区 ID
                        const selectedAreaIds = [];
                        if (window.vueAppInstance && window.vueAppInstance.v3AreaState) {
                            const areaState = window.vueAppInstance.v3AreaState;
                            areaState.selectedProvinces.forEach(id => selectedAreaIds.push(id));
                            areaState.selectedCities.forEach(id => selectedAreaIds.push(id));
                            areaState.selectedDistricts.forEach(id => selectedAreaIds.push(id));
                        }

                        if (selectedAreaIds.length > 0) {
                            configData.areaUpdate = {
                                pricingId: window.V3StrategyEditModal.currentEditingPricingId,
                                selectedAreaIds: selectedAreaIds,
                                operator: 'admin'
                            };
                        }
                    }

                    console.log('📦 准备调用整合接口，数据:', configData);

                    // 调用整合的后端接口
                    // ========== 问题修复：使用统一API调用 ==========
                    const result = await unifiedApiCall(
                        'saveAllConfig',
                        '/strategy-area-pricing/save-all-config',
                        configData
                    );
                    // ========== 问题修复结束 ==========
                    console.log('📨 整合接口响应:', result);

                    if (result.code === 0) {
                        const resultData = result.data;

                        if (resultData.failCount === 0) {
                            console.log('🎉 保存成功！新增配置:', resultData.newAreaConfigResult?.successCount || 0, '个');
                            console.log('🎉 更新配置:', resultData.areaPricingResult?.successCount || 0, '个');
                            console.log('🎉 删除配置:', resultData.areaPricingDeletionResult?.successCount || 0, '个');

                            // 显示详细的成功信息，延长显示时间
                            const successDetails = [];
                            if (resultData.newAreaConfigResult?.successCount > 0) {
                                successDetails.push(`新增 ${resultData.newAreaConfigResult.successCount} 个地区配置`);
                            }
                            if (resultData.areaPricingResult?.successCount > 0) {
                                successDetails.push(`更新 ${resultData.areaPricingResult.successCount} 个配置`);
                            }
                            if (resultData.areaPricingDeletionResult?.successCount > 0) {
                                successDetails.push(`删除 ${resultData.areaPricingDeletionResult.successCount} 个配置`);
                            }
                            if (resultData.weightRuleResult?.successCount > 0) {
                                successDetails.push(`更新 ${resultData.weightRuleResult.successCount} 个重量规则`);
                            }
                            if (resultData.weightRuleDeletionResult?.successCount > 0) {
                                successDetails.push(`删除 ${resultData.weightRuleDeletionResult.successCount} 个重量规则`);
                            }
                            if (resultData.newWeightRuleResult?.successCount > 0) {
                                successDetails.push(`新增 ${resultData.newWeightRuleResult.successCount} 个重量规则`);
                            }

                            const detailMsg = successDetails.length > 0
                                ? `保存成功！${successDetails.join('、')}。正在刷新数据...`
                                : '所有配置保存成功！正在刷新数据...';

                            showMessage(detailMsg); // 使用默认的 3 秒显示时间

                            // 如果有新增地区配置，需要刷新重量规则下拉框
                            if (resultData.newAreaConfigResult?.successCount > 0) {
                                console.log('🔄 检测到新增地区配置，刷新重量规则下拉框...');
                                setTimeout(() => {
                                    refreshWeightRulePricingOptions();
                                }, 500); // 延迟500ms确保数据已更新
                            }

                            // 清除修改标记
                            const allModifiedInputs = document.querySelectorAll('#strategy-edit-modal .table-input.modified');
                            allModifiedInputs.forEach(input => {
                                input.classList.remove('modified');
                            });

                            // 清除编辑模式标记
                            if (window.V3StrategyEditModal) {
                                window.V3StrategyEditModal.currentEditingPricingId = null;
                            }
                            if (window.vueAppInstance) {
                                window.vueAppInstance.currentEditingPricingId = null;
                            }

                            // 🔧 [修复] 在清空暂存配置之前，先保存用户在重量区间配置中的选择状态
                            const weightRuleSelections = new Map();
                            const pricingSelects = document.querySelectorAll('.pricing-select');
                            pricingSelects.forEach(select => {
                                const ruleId = select.getAttribute('data-id');
                                const selectedValue = select.value;
                                const selectedText = select.selectedOptions[0]?.textContent || '';
                                if (ruleId && selectedValue) {
                                    weightRuleSelections.set(ruleId, {
                                        value: selectedValue,
                                        text: selectedText
                                    });
                                    console.log('💾 保存重量规则选择状态:', ruleId, '->', selectedValue, selectedText);
                                }
                            });

                            // 清除延迟保存的数据
                            if (window.pendingNewAreaConfigs) {
                                window.pendingNewAreaConfigs.clear();
                            }
                            if (window.pendingAreaChanges) {
                                window.pendingAreaChanges.clear();
                            }
                            if (window.pendingWeightRules) {
                                window.pendingWeightRules = [];
                            }
                            if (window.pendingAreaPricingDeletions) {
                                window.pendingAreaPricingDeletions = [];
                            }

                            // 移除标记删除的行
                            const deletedWeightRows = document.querySelectorAll('#weight-rules-list tr.marked-for-deletion');
                            deletedWeightRows.forEach(row => row.remove());

                            const deletedAreaRows = document.querySelectorAll('#area-pricing-list tr.marked-for-deletion');
                            deletedAreaRows.forEach(row => row.remove());

                            // 移除已确认的新增重量规则标记（因为已经保存到数据库）
                            const confirmedNewRuleRows = document.querySelectorAll('#weight-rules-list tr.confirmed-new-rule');
                            confirmedNewRuleRows.forEach(row => {
                                row.classList.remove('confirmed-new-rule');
                                console.log('✅ 清除已保存的新增重量规则标记:', row.getAttribute('data-rule-id'));
                            });

                            // 重新加载策略配置数据以确保界面同步
                            setTimeout(() => {
                                console.log('🔄 正在刷新界面数据，同步最新的保存结果...');
                                if (window.V3StrategyEditModal && window.V3StrategyEditModal.currentStrategy) {
                                    initStrategyEditModal(window.V3StrategyEditModal.currentStrategy).then(() => {
                                        // 🔧 [修复] 数据重新加载后，恢复用户之前的选择状态
                                        setTimeout(() => {
                                            console.log('🔄 开始恢复重量规则选择状态...');
                                            const currentPricingSelects = document.querySelectorAll('.pricing-select');
                                            let restoredCount = 0;

                                            currentPricingSelects.forEach(select => {
                                                const ruleId = select.getAttribute('data-id');
                                                const savedSelection = weightRuleSelections.get(ruleId);

                                                if (savedSelection) {
                                                    // 先尝试直接恢复原值
                                                    let restored = false;
                                                    Array.from(select.options).forEach(option => {
                                                        if (option.value === savedSelection.value) {
                                                            select.value = savedSelection.value;
                                                            restored = true;
                                                            restoredCount++;
                                                            console.log('✅ 直接恢复选择:', ruleId, '->', savedSelection.value, savedSelection.text);
                                                        }
                                                    });

                                                    // 如果原值不存在（暂存配置已保存），尝试按名称匹配
                                                    if (!restored && savedSelection.text) {
                                                        Array.from(select.options).forEach(option => {
                                                            if (option.textContent.includes(savedSelection.text.replace(' (暂存)', ''))) {
                                                                select.value = option.value;
                                                                restoredCount++;
                                                                console.log('✅ 按名称匹配恢复选择:', ruleId, '->', option.value, option.textContent);
                                                            }
                                                        });
                                                    }
                                                }
                                            });

                                            console.log('🎉 恢复重量规则选择状态完成，恢复数量:', restoredCount);
                                        }, 300); // 等待下拉框数据加载完成
                                    });
                                }
                                // 刷新完成后显示最终确认信息
                                setTimeout(() => {
                                    showMessage('✅ 数据刷新完成！您的配置已成功保存并应用');
                                }, 800);
                            }, 1000); // 延迟1秒刷新，让用户看到成功信息

                        } else if (resultData.successCount > 0) {
                            showMessage(`部分保存成功，成功：${resultData.successCount}，失败：${resultData.failCount}`, true);
                            if (resultData.errorMessages && resultData.errorMessages.length > 0) {
                                console.error('错误详情:', resultData.errorMessages);
                            }
                        } else {
                            showMessage('保存全部失败', true);
                            if (resultData.errorMessages && resultData.errorMessages.length > 0) {
                                console.error('错误详情:', resultData.errorMessages);
                            }
                        }
                    } else {
                        throw new Error(result.msg || '保存失败');
                    }

                } catch (error) {
                    console.error('保存配置失败:', error);
                    showMessage('保存失败: ' + error.message, true);
                }
            },

            // 删除地区定价（修改为延迟保存模式）
            deleteAreaPricing: function (pricingId) {
                // if (!confirm('确定要删除这个地区定价配置吗？删除操作将由"保存所有配置"按钮统一处理！')) {
                //     return;
                // }

                try {
                    console.log('标记删除地区定价配置，配置ID:', pricingId);

                    // 找到对应的行
                    const row = document.querySelector(`tr[data-pricing-id="${pricingId}"]`);
                    if (row) {
                        // 标记为待删除
                        row.classList.add('marked-for-deletion');
                        row.style.backgroundColor = '#ffebee';
                        row.style.opacity = '0.6';

                        // 禁用所有输入框
                        const inputs = row.querySelectorAll('input, select');
                        inputs.forEach(input => {
                            input.setAttribute('disabled', true);
                        });

                        // 更新操作按钮
                        const actionCell = row.querySelector('td:last-child');
                        if (actionCell) {
                            actionCell.innerHTML = `
                                <div class="action-buttons">
                                    <span class="status-text text-danger">
                                        <i class="icon-delete"></i> 标记删除，等待保存
                                    </span>
                                    <button class="btn-small btn-secondary" 
                                            onclick="window.V3StrategyEditModal.undoDeleteAreaPricing(${pricingId})" 
                                            title="撤销删除">
                                        <i class="icon-undo"></i> 撤销
                                    </button>
                                </div>
                            `;
                        }

                        // 初始化全局删除数组
                        if (!window.pendingAreaPricingDeletions) {
                            window.pendingAreaPricingDeletions = [];
                        }

                        // 添加到待删除列表
                        if (!window.pendingAreaPricingDeletions.includes(pricingId)) {
                            window.pendingAreaPricingDeletions.push(pricingId);
                        }

                        showMessage('地区配置已标记为删除，请点击"保存所有配置"按钮统一处理');
                    } else {
                        throw new Error('未找到对应的配置行');
                    }
                } catch (error) {
                    console.error('标记删除地区配置失败:', error);
                    showMessage('标记删除失败: ' + error.message, true);
                }
            },

            // 撤销删除地区定价配置
            undoDeleteAreaPricing: function (pricingId) {
                try {
                    console.log('撤销删除地区定价配置，配置ID:', pricingId);

                    // 找到对应的行
                    const row = document.querySelector(`tr[data-pricing-id="${pricingId}"]`);
                    if (row) {
                        // 移除删除标记
                        row.classList.remove('marked-for-deletion');
                        row.style.backgroundColor = '';
                        row.style.opacity = '';

                        // 重新启用所有输入框
                        const inputs = row.querySelectorAll('input, select');
                        inputs.forEach(input => {
                            input.removeAttribute('disabled');
                        });

                        // 恢复操作按钮
                        const actionCell = row.querySelector('td:last-child');
                        if (actionCell) {
                            actionCell.innerHTML = `
                                <div class="action-buttons">
                                    <button class="btn-small btn-danger" 
                                            onclick="window.V3StrategyEditModal.deleteAreaPricing(${pricingId})" 
                                            title="删除配置">
                                        <i class="icon-delete"></i> 删除
                                    </button>
                                </div>
                            `;
                        }

                        // 从待删除列表中移除
                        if (window.pendingAreaPricingDeletions) {
                            const index = window.pendingAreaPricingDeletions.indexOf(pricingId);
                            if (index > -1) {
                                window.pendingAreaPricingDeletions.splice(index, 1);
                            }
                        }

                        showMessage('已撤销删除标记');
                    } else {
                        throw new Error('未找到对应的配置行');
                    }
                } catch (error) {
                    console.error('撤销删除失败:', error);
                    showMessage('撤销删除失败: ' + error.message, true);
                }
            },


            // 删除重量规则（修改为不直接调用后端，仅标记删除状态）
            deleteWeightRule: function (ruleId) {
                // if (!confirm('确定要删除这个重量区间规则吗？删除操作将由"保存所有配置"按钮统一处理！')) {
                //     return;
                // }

                try {
                    console.log('标记删除重量规则，规则ID:', ruleId);

                    // 找到对应的行
                    const row = document.querySelector(`tr[data-rule-id="${ruleId}"]`);
                    if (row) {
                        // 标记为待删除
                        row.classList.add('marked-for-deletion');
                        row.style.backgroundColor = '#ffebee';
                        row.style.opacity = '0.6';

                        // 禁用所有输入框
                        const inputs = row.querySelectorAll('input, select');
                        inputs.forEach(input => {
                            input.setAttribute('disabled', true);
                        });

                        // 更新操作按钮
                        const actionCell = row.querySelector('td:last-child');
                        if (actionCell) {
                            actionCell.innerHTML = `
                                <div class="action-buttons">
                                    <span class="status-text text-danger">
                                        <i class="icon-delete"></i> 标记删除，等待保存
                                    </span>
                                    <button class="btn-small btn-secondary" 
                                            onclick="window.V3StrategyEditModal.undoDeleteWeightRule(${ruleId})" 
                                            title="撤销删除">
                                        <i class="icon-undo"></i> 撤销
                                    </button>
                                </div>
                            `;
                        }

                        showMessage('重量规则已标记为删除，请点击"保存所有配置"按钮统一处理');
                    } else {
                        throw new Error('未找到对应的规则行');
                    }
                } catch (error) {
                    console.error('标记删除重量规则失败:', error);
                    showMessage('标记删除失败: ' + error.message, true);
                }
            },

            // 撤销删除重量规则
            undoDeleteWeightRule: function (ruleId) {
                try {
                    console.log('撤销删除重量规则，规则ID:', ruleId);

                    // 找到对应的行
                    const row = document.querySelector(`tr[data-rule-id="${ruleId}"]`);
                    if (row) {
                        // 移除删除标记
                        row.classList.remove('marked-for-deletion');
                        row.style.backgroundColor = '';
                        row.style.opacity = '';

                        // 重新启用所有输入框
                        const inputs = row.querySelectorAll('input, select');
                        inputs.forEach(input => {
                            input.removeAttribute('disabled');
                        });

                        // 恢复操作按钮
                        const actionCell = row.querySelector('td:last-child');
                        if (actionCell) {
                            actionCell.innerHTML = `
                                <div class="action-buttons">
                                    <button class="btn-small btn-danger" 
                                            onclick="window.V3StrategyEditModal.deleteWeightRule(${ruleId})" 
                                            title="删除规则">
                                        <i class="icon-delete"></i> 删除
                                    </button>
                                </div>
                            `;
                        }

                        showMessage('已撤销删除标记');
                    } else {
                        throw new Error('未找到对应的规则行');
                    }
                } catch (error) {
                    console.error('撤销删除失败:', error);
                    showMessage('撤销删除失败: ' + error.message, true);
                }
            },

            // 立即刷新地区显示（新增方法）
            refreshAreaDisplay: async function () {
                try {
                    console.log('🔄 立即刷新地区显示...');

                    // 重新加载地区配置数据
                    const areaPricingData = await loadStrategyAreaPricingData(this.currentStrategy.id);

                    // 使用统一的渲染方法，会自动处理暂存的新增配置
                    await renderAreaPricingTable(areaPricingData);

                    console.log('✅ 地区显示刷新完成，包含暂存数据');

                } catch (error) {
                    console.error('❗ 刷新地区显示失败:', error);
                    // 错误时显示错误状态
                    const modalAreaPricingList = document.querySelector('#area-pricing-list');
                    if (modalAreaPricingList) {
                        modalAreaPricingList.innerHTML = `
                            <tr>
                                <td colspan="9" class="empty-cell">
                                    <div class="error-state">
                                        <p>加载失败，请重试</p>
                                        <button class="btn btn-primary btn-small" onclick="window.V3StrategyEditModal.refreshAreaDisplay()">
                                            重新加载
                                        </button>
                                    </div>
                                </td>
                            </tr>
                        `;
                    }
                }
            }
        };

        // 创建弹框HTML，专注于地区和计费规则编辑
        const modalHtml = `
            <div id="strategy-edit-modal" class="modal-overlay">
                <div class="modal-container strategy-edit-modal">
                    <div class="modal-header">
                        <h2>编辑策略配置 - ${strategy.name || '未命名策略'}</h2>
                        <button class="modal-close" onclick="closeStrategyEditModal()">×</button>
                    </div>
                    
                    <div class="modal-content">
                        <!-- 策略信息显示区域（只读） -->
                        <div class="strategy-info-display">
                            <div class="info-card">
                                <h4><i class="icon-info"></i> 当前策略信息</h4>
                                <div class="info-grid">
                                    <div class="info-item">
                                        <span class="label">策略名称：</span>
                                        <span class="value">${strategy.name || '未命名'}</span>
                                    </div>
                                    <div class="info-item">
                                        <span class="label">计费模式：</span>
                                        <span class="value">${strategy.pricingModel === 1 ? '首重续重' : '首重续重+重量区间'}</span>
                                    </div>
                                    <div class="info-item">
                                        <span class="label">状态：</span>
                                        <span class="value">
                                            <span class="status-badge status-${strategy.status === 1 ? 'active' : 'inactive'}">
                                                ${strategy.status === 1 ? '启用' : '禁用'}
                                            </span>
                                        </span>
                                    </div>
                                    <div class="info-item full-width">
                                        <span class="label">策略描述：</span>
                                        <span class="value">${strategy.description || '无描述'}</span>
                                    </div>
                                </div>
                            </div>
                        </div>
                        
                        <!-- 地区配置管理 -->
                        <div class="config-section area-management-section">
                            <div class="section-header">
                                <h3><i class="icon-location"></i> 地区配置管理</h3>
                                <button class="btn btn-primary btn-small" onclick="window.V3StrategyEditModal.currentEditingPricingId = null; window.V3StrategyEditModal.openAreaSelector(${strategy.id});">
                                    <i class="icon-plus"></i> 添加地区
                                </button>
                            </div>
                            
                            <div class="area-pricing-table">
                                <table class="config-table">
                                    <thead>
                                        <tr>
                                            <th width="12%">配置名称</th>
                                            <th width="20%">地区</th>
                                            <th width="8%">首重重量(kg)</th>
                                            <th width="8%">首重资费(元)</th>
                                            <th width="8%">续重重量(kg)</th>
                                            <th width="8%">续重资费(元)</th>
                                            <th width="8%">抛重比</th>
                                            <th width="18%">描述</th>
                                            <th width="10%">操作</th>
                                        </tr>
                                    </thead>
                                    <tbody id="area-pricing-list">
                                        <!-- 动态生成地区配置列表 -->
                                    </tbody>
                                </table>
                            </div>
                        </div>

                        <!-- 重量区间配置（仅在计费模式为“首重续重+重量区间”时显示） -->
                        <div class="config-section weight-rules-section" id="weight-rules-section" style="display: ${strategy.pricingModel === 1 ? 'none' : 'block'}">
                            <div class="section-header">
                                <h3><i class="icon-weight"></i> 重量区间配置</h3>
                                <button class="btn btn-secondary btn-small" onclick="window.V3StrategyEditModal.addWeightRule()">
                                    <i class="icon-plus"></i> 添加区间规则
                                </button>
                            </div>
                            
                            <div class="weight-rules-table">
                                <table class="config-table">
                                    <thead>
                                        <tr>
                                            <th width="40%">应用地区定价配置名称</th>
                                            <th width="20%">重量上限（kg）</th>
                                            <th width="20%">区间费用（元）</th>
                                            <th width="20%">操作</th>
                                        </tr>
                                    </thead>
                                    <tbody id="weight-rules-list">
                                        <!-- 动态生成重量区间列表 -->
                                    </tbody>
                                </table>
                            </div>
                        </div>
                        
                        <!-- 计费模式提示（仅在计费模式为“首重续重”时显示） -->
                        <div class="config-section pricing-mode-notice" id="pricing-mode-notice" style="display: ${strategy.pricingModel === 1 ? 'block' : 'none'}">
                            <div class="notice-content">
                                <i class="icon-info"></i>
                                <h4>当前策略使用“首重续重”计费模式</h4>
                                <p>重量区间配置仅在“首重续重+重量区间”模式下可用</p>
                                <p class="notice-hint">如需使用重量区间功能，请在策略管理中修改计费模式</p>
                            </div>
                        </div>
                    </div>
                    
                    <div class="modal-footer">
                        <button class="btn btn-secondary" onclick="closeStrategyEditModal()">关闭</button>
                        <button class="btn btn-primary" onclick="window.V3StrategyConfigManager.saveAreaPricingConfigV2(${strategy.id})">
                            <i class="icon-save"></i> 保存所有配置（简化版本）
                        </button>
                    </div>
                </div>
            </div>
        `;

        // 添加到页面
        document.body.insertAdjacentHTML('beforeend', modalHtml);

        // 初始化弹框数据
        initStrategyEditModal(strategy);

        // 绑定ESC关闭事件
        document.addEventListener('keydown', function handleEscKey(e) {
            if (e.key === 'Escape') {
                closeStrategyEditModal();
                document.removeEventListener('keydown', handleEscKey);
            }
        });
    }

    /**
     * 初始化策略编辑弹框数据
     */
    async function initStrategyEditModal(strategy) {
        try {
            console.log('📊 初始化策略编辑弹框数据:', strategy.id);

            // 显示加载状态
            const areaPricingList = document.getElementById('area-pricing-list');
            const weightRulesList = document.getElementById('weight-rules-list');

            if (areaPricingList) {
                areaPricingList.innerHTML = '<tr><td colspan="9" class="loading-cell">正在加载地区配置...</td></tr>';
            }
            if (weightRulesList) {
                weightRulesList.innerHTML = '<tr><td colspan="7" class="loading-cell">正在加载重量区间配置...</td></tr>';
            }

            // 确保地区树数据已加载（用于地区ID到名称的转换）
            console.log('🌳 检查地区树数据状态...');
            if (!window.vueAppInstance || !window.vueAppInstance.areaTree ||
                !window.vueAppInstance.areaTree.value || window.vueAppInstance.areaTree.value.length === 0) {
                console.log('🔄 地区树数据未加载，尝试加载...');
                try {
                    // 尝试从缓存管理器加载地区树数据
                    if (window.areaCacheManager && typeof window.areaCacheManager.preloadAreaTree === 'function') {
                        console.log('✅ 地区缓存管理器可用，开始预加载地区树数据...');
                        await window.areaCacheManager.preloadAreaTree();
                        console.log('✅ 地区树数据预加载完成');
                    } else {
                        console.warn('⚠️ 地区缓存管理器不可用', {
                            areaCacheManager: !!window.areaCacheManager,
                            preloadMethod: window.areaCacheManager ? typeof window.areaCacheManager.preloadAreaTree : 'undefined'
                        });
                        // 尝试手动加载地区数据
                        if (window.vueAppInstance && window.vueAppInstance.loadAreaTree) {
                            console.log('🔄 尝试通过Vue实例加载地区数据...');
                            await window.vueAppInstance.loadAreaTree();
                        }
                    }
                } catch (areaTreeError) {
                    console.warn('⚠️ 地区树数据加载失败，可能影响地区名称显示:', areaTreeError);
                }
            } else {
                console.log('✅ 地区树数据已加载，省份数量:', window.vueAppInstance.areaTree.value.length);
            }

            // 加载真实数据
            console.log('🔄 开始加载数据...');

            let areaPricingData = [];
            let weightRulesData = [];

            try {
                const unifiedData = await loadUnifiedStrategyData(strategy.id);
                areaPricingData = unifiedData.areaPricing;
                weightRulesData = unifiedData.weightRules;
                console.log('✅ 统一数据加载成功 - 地区定价:', areaPricingData.length, '条, 重量规则:', weightRulesData.length, '条');
            } catch (error) {
                console.error('❌ 统一数据加载失败:', error);
                areaPricingData = [];
                weightRulesData = [];
            }

            // 渲染表格
            console.log('🎨 开始渲染表格...');
            renderAreaPricingTable(areaPricingData);
            renderWeightRulesTable(weightRulesData);
            console.log('✅ 表格渲染完成');

            // 🔧 重要：表格渲染完成后立即初始化重量区间下拉框数据
            setTimeout(() => {
                initPricingSelectOptions();
                console.log('🎯 [修复] 策略编辑模态框打开时下拉框数据已初始化');
            }, 200);

            // 🔧 [修复] 额外确保重量区间下拉框数据正确加载
            setTimeout(() => {
                initWeightRulesPagePricingOptions();
                console.log('🎯 [修复] 重量区间页面下拉框数据二次确认初始化');
            }, 500);

        } catch (error) {
            console.error('❌ 初始化策略编辑弹框失败:', error);
            showMessage('加载策略数据失败: ' + error.message, true);

            // 错误时显示空状态
            const areaPricingList = document.getElementById('area-pricing-list');
            const weightRulesList = document.getElementById('weight-rules-list');

            if (areaPricingList) {
                areaPricingList.innerHTML = '<tr><td colspan="9" class="empty-cell"><div class="empty-state"><p>加载失败，请重试</p></div></td></tr>';
            }
            if (weightRulesList) {
                weightRulesList.innerHTML = '<tr><td colspan="7" class="empty-cell"><div class="empty-state"><p>加载失败，请重试</p></div></td></tr>';
            }
        }
    }

    /**
     * 加载策略定价数据
     */
    async function loadStrategyPricingData(strategyId) {
        try {
            // 查询策略的定价配置
            // ========== 问题修复：使用统一API调用 ==========
            const result = await unifiedApiCall(
                'getStrategyAreaPricingList',
                '/strategy-area-pricing/list',
                {strategyId: strategyId}
            );
            // ========== 问题修复结束 ==========
            if (result.code === 0) {
                return result.data || [];
            } else {
                throw new Error(result.msg || '查询失败');
            }
        } catch (error) {
            console.error('加载策略定价数据失败:', error);
            return [];
        }
    }

    /**
     * 渲染地区标签，包含data-area-id属性
     */
    function renderAreaTags(item) {
        const areas = item.areas || item.areaNames || [];
        const areaIds = item.areaIds || [];

        // 如果有地区ID信息，就创建带ID的标签
        if (areaIds.length > 0 && areaIds.length === areas.length) {
            return areas.map((areaName, index) => {
                const areaId = areaIds[index];
                return `<span class="area-tag" data-area-id="${areaId}">${areaName}</span>`;
            }).join('');
        } else {
            // 回退到纯文本模式
            return areas.map(areaName => `<span class="area-tag">${areaName}</span>`).join('');
        }
    }

    /**
     * 渲染地区定价表格
     */
    async function renderAreaPricingTable(data) {
        const tbody = document.getElementById('area-pricing-list');
        if (!tbody) return;

        // 合并已保存的数据和暂存的新增配置
        const allData = [...(data || [])];

        // 添加暂存的新增配置
        if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.size > 0) {
            console.log('📝 检测到暂存的新增配置:', window.pendingNewAreaConfigs.size, '个');

            // 使用for...of循环来正确处理异步操作
            for (const [tempId, config] of window.pendingNewAreaConfigs) {
                console.log('📋 处理暂存配置:', tempId, config);

                // 从选中的地区ID获取地区名称
                const areaNames = [];
                if (config.selectedAreaIds && config.selectedAreaIds.length > 0) {
                    console.log('🔍 处理选中的地区ID:', config.selectedAreaIds);

                    // 使用Promise.all并行获取所有地区名称
                    const areaNamePromises = config.selectedAreaIds.map(async areaId => {
                        try {
                            const areaName = await findAreaNameByIdAsync(areaId);
                            if (areaName && !areaName.includes('地区ID:')) {
                                console.log('✅ 找到地区名称:', areaId, '->', areaName);
                                return areaName;
                            } else {
                                console.warn('⚠️ 未找到地区ID对应的名称:', areaId);
                                // 如果找不到名称，尝试从Vue实例的地区树中查找
                                const vueAreaName = findAreaNameFromVueTree(areaId);
                                if (vueAreaName) {
                                    console.log('✅ 从Vue树中找到地区名称:', areaId, '->', vueAreaName);
                                    return vueAreaName;
                                } else {
                                    return `地区ID:${areaId}`;
                                }
                            }
                        } catch (error) {
                            console.warn('⚠️ 获取地区名称失败:', areaId, error);
                            return `地区ID:${areaId}`;
                        }
                    });

                    // 等待所有地区名称获取完成
                    const resolvedAreaNames = await Promise.all(areaNamePromises);
                    areaNames.push(...resolvedAreaNames);
                } else {
                    console.warn('⚠️ 暂存配置没有选中的地区ID');
                }

                // 构建显示数据，包含地区ID映射
                const displayData = {
                    id: tempId,
                    name: config.name || '新增配置',
                    areas: areaNames.length > 0 ? areaNames : ['已选择地区'],
                    areaIds: config.selectedAreaIds || [], // 保存地区ID信息用于重复检查
                    firstWeightKg: config.firstWeightKg || 0,
                    firstWeightFee: config.firstWeightFee || 0,
                    additionalWeightKg: config.additionalWeightKg || 0,
                    additionalWeightFee: config.additionalWeightFee || 0,
                    volumetricWeightRatio: config.volumetricWeightRatio || 0,
                    description: config.description || '新增的地区配置，等待保存',
                    status: config.status || 1,
                    isPending: true // 标记为暂存状态
                };

                allData.push(displayData);
            }
        }

        if (allData.length === 0) {
            tbody.innerHTML = `
                <tr>
                    <td colspan="9" class="empty-cell">
                        <div class="empty-state">
                            <i class="icon-location"></i>
                            <p>暂无地区配置</p>
                            <p class="empty-hint">请先添加地区</p>
                            <button class="btn btn-primary btn-small" onclick="window.V3StrategyEditModal.currentEditingPricingId = null; window.V3StrategyEditModal.openAreaSelector();">
                                添加第一个地区
                            </button>
                        </div>
                    </td>
                </tr>
            `;
            return;
        }

        tbody.innerHTML = allData.map(item => {
            // 🔧 [修复] 为暂存配置添加绿色边框样式类，参考重量区间配置
            const rowClass = item.isPending ? 'pending-row new-area-config' : '';

            return `
                <tr data-pricing-id="${item.id}" class="${rowClass}" ${item.isPending ? 'data-temp-id="' + item.id + '"' : ''}>
                    <td>
                        <input type="text" value="${item.name || ''}" 
                               class="table-input name-input" 
                               data-field="name" data-id="${item.id}" 
                               placeholder="请输入配置名称" 
                               onchange="handleConfigNameChange(this)">
                    </td>
                    <td>
                        <div class="area-info clickable-area" onclick="editAreaInfo(${item.id})">
                            <div class="area-tags">
                                ${renderAreaTags(item)}
                            </div>
                            ${item.isPending ? '<span class="pending-badge">暂存</span>' : ''}
                        </div>
                    </td>
                    <td>
                        <input type="number" value="${item.firstWeightKg || 1}" 
                               step="0.1" min="0.0" class="table-input weight-input" 
                               data-field="firstWeightKg" data-id="${item.id}">
                    </td>
                    <td>
                        <input type="number" value="${item.firstWeightFee || 0}" 
                               step="0.1" min="0" class="table-input fee-input" 
                               data-field="firstWeightFee" data-id="${item.id}">
                    </td>
                    <td>
                        <input type="number" value="${item.additionalWeightKg || 1}" 
                               step="0.1" min="0.0" class="table-input weight-input" 
                               data-field="additionalWeightKg" data-id="${item.id}">
                    </td>
                    <td>
                        <input type="number" value="${item.additionalWeightFee || 0}" 
                               step="0.1" min="0" class="table-input fee-input" 
                               data-field="additionalWeightFee" data-id="${item.id}">
                    </td>
                    <td>
                        <input type="number" value="${item.volumetricWeightRatio !== undefined && item.volumetricWeightRatio !== null ? item.volumetricWeightRatio : ''}" 
                               step="100" min="0" class="table-input ratio-input" 
                               data-field="volumetricWeightRatio" data-id="${item.id}">
                    </td>
                    <td>
                        <input type="text" value="${item.description || ''}" 
                               class="table-input description-input" 
                               data-field="description" data-id="${item.id}" 
                               placeholder="请输入描述">
                    </td>
                    <td>
                        <div class="action-buttons">
                            ${item.isPending ?
                `<button class="btn-small btn-success" 
                                         onclick="saveNewAreaConfig('${item.id}')" 
                                         title="保存配置">
                                     <i class="icon-save"></i> 保存
                                 </button>
                                 <button class="btn-small btn-danger" 
                                         onclick="cancelPendingAreaConfig('${item.id}')" 
                                         title="取消暂存配置">
                                     <i class="icon-cancel"></i> 取消
                                 </button>` :
                `<button class="btn-small btn-danger" 
                                         onclick="window.V3StrategyEditModal.deleteAreaPricing(${item.id})" 
                                         title="删除配置">
                                     <i class="icon-delete"></i> 删除
                                 </button>`
            }
                        </div>
                    </td>
                </tr>
            `;
        }).join('');

        // 绑定输入框变化事件
        bindTableInputEvents();

        console.log('✅ 地区配置表格渲染完成，总记录数:', allData.length);
    }

    /**
     * 根据地区ID查找地区名称（增强版，支持API回退）
     */
    async function findAreaNameById(areaId) {
        console.log('🔍 查找地区名称, ID:', areaId);

        // 检查Vue实例和地区树数据
        if (window.vueAppInstance && window.vueAppInstance.areaTree) {
            const areaTree = window.vueAppInstance.areaTree.value || [];
            if (areaTree.length > 0) {
                console.log('🌳 地区树数据可用，省份数量:', areaTree.length);

                // 递归查找地区，支持多种名称字段的回退机制
                function searchArea(nodes, level = 1) {
                    for (const node of nodes) {
                        if (node.id == areaId) {
                            console.log(`✅ 找到地区: ${node.name} (级别: ${level})`);

                            // 支持多种名称字段的回退机制
                            let displayName = node.name || node.fullName || node.areaName;

                            // 根据区域级别构造更完整的名称
                            if (level === 3 && node.districtName) {
                                // 区县级：显示省市区全名
                                const provinceName = node.provinceName || node.name;
                                const cityName = node.cityName || '';
                                const districtName = node.districtName || node.name;
                                displayName = `${provinceName}-${cityName}-${districtName}`;
                            } else if (level === 2 && node.cityName) {
                                // 市级：显示省市名
                                const provinceName = node.provinceName || '';
                                const cityName = node.cityName || node.name;
                                displayName = `${provinceName}-${cityName}`;
                            } else if (level === 1 && node.provinceName) {
                                // 省级：显示省名
                                displayName = node.provinceName || node.name;
                            }

                            return displayName || node.name || `地区ID:${areaId}`;
                        }
                        if (node.children && node.children.length > 0) {
                            const result = searchArea(node.children, level + 1);
                            if (result) return result;
                        }
                    }
                    return null;
                }

                const areaName = searchArea(areaTree);
                if (areaName) {
                    return areaName;
                }
            }
        }

        // 地区树不可用时，尝试通过后端API获取地区名称
        console.log('⚠️ 地区树不可用，尝试通过API获取地区名称...');
        try {
            // 使用统一API服务
            const result = await unifiedApiCall(
                'getAreaById',
                '/area/get-by-id',
                {id: parseInt(areaId)}
            );

            if (result.code === 0 && result.data) {
                const area = result.data;
                let displayName = area.name || area.fullName || area.areaName;

                // 根据地区级别构造完整名称
                if (area.level === 3 && area.districtName) {
                    displayName = `${area.provinceName || ''}-${area.cityName || ''}-${area.districtName || area.name}`;
                } else if (area.level === 2 && area.cityName) {
                    displayName = `${area.provinceName || ''}-${area.cityName || area.name}`;
                } else if (area.level === 1 && area.provinceName) {
                    displayName = area.provinceName || area.name;
                }

                console.log('✅ 从 API 获取到地区名称:', displayName);
                return displayName;
            } else {
                console.warn('⚠️ API返回错误或无数据:', result);
            }
        } catch (apiError) {
            console.warn('⚠️ API获取地区名称失败:', apiError);
        }

        // 最后尝试从 DOM 中查找
        console.log('⚠️ 尝试从 DOM 中查找地区名称...');
        const nameFromDOM = findAreaNameFromDOM(areaId);
        if (nameFromDOM && !nameFromDOM.includes('地区ID:')) {
            console.log('✅ 从 DOM 中找到地区名称:', nameFromDOM);
            return nameFromDOM;
        }

        console.warn(`⚠️ 未找到地区ID ${areaId} 对应的地区名称`);
        return `地区ID:${areaId}`;
    }

    /**
     * 统一的XMLHttpRequest调用函数（包含context-path处理）
     */
    function createXHRWithPrefix(method, url, async = true, data = null) {
        const fixedUrl = fixApiPath(url);
        const xhr = new XMLHttpRequest();
        xhr.open(method, fixedUrl, async);
        if (data) {
            xhr.setRequestHeader('Content-Type', 'application/json;charset=UTF-8');
        }
        return xhr;
    }

    /**
     * 同步版本的查找地区名称（保持向后兼容）
     */
    async function findAreaNameByIdAsync(areaId) {
        console.log('🔍 异步查找地区名称, ID:', areaId);

        // 检查Vue实例和地区树数据
        if (!window.vueAppInstance) {
            console.warn('⚠️ Vue实例不可用');
            // 尝试通过API获取地区名称
            try {
                // 使用统一的API调用方式
                const result = await unifiedApiCall(
                    'getAreaById',
                    '/area/get-by-id',
                    {id: parseInt(areaId)}
                );

                if (result.code === 0 && result.data) {
                    const area = result.data;
                    let displayName = area.name || area.fullName || area.areaName;

                    // 根据地区级别构造完整名称
                    if (area.level === 3 && area.districtName) {
                        displayName = `${area.provinceName || ''}-${area.cityName || ''}-${area.districtName || area.name}`;
                    } else if (area.level === 2 && area.cityName) {
                        displayName = `${area.provinceName || ''}-${area.cityName || area.name}`;
                    } else if (area.level === 1 && area.provinceName) {
                        displayName = area.provinceName || area.name;
                    }

                    console.log('✅ 从统一API获取到地区名称:', displayName);
                    return displayName;
                }
            } catch (apiError) {
                console.warn('⚠️ 统一API获取地区名称失败:', apiError);
            }

            // 如果API获取失败，尝试从已显示的地区配置中查找名称
            const nameFromDOM = findAreaNameFromDOM(areaId);
            if (nameFromDOM && !nameFromDOM.includes('地区ID:')) {
                console.log('✅ 从 DOM 中找到地区名称:', nameFromDOM);
                return nameFromDOM;
            }
            return `地区ID:${areaId}`;
        }

        if (!window.vueAppInstance.areaTree) {
            console.warn('⚠️ 地区树数据不可用');
            // 尝试通过API获取地区名称
            try {
                // ========== 问题修复：使用统一API调用 ==========
                const areaInfo = await getAreaByIdUnified(areaId);
                if (areaInfo && areaInfo.displayName) {
                    return areaInfo.displayName;
                }
                // ========== 问题修复结束 ==========
            } catch (apiError) {
                console.warn('⚠️ API获取地区名称失败:', apiError);
            }

            // 如果API获取失败，尝试从已显示的地区配置中查找名称
            const nameFromDOM = findAreaNameFromDOM(areaId);
            if (nameFromDOM && !nameFromDOM.includes('地区ID:')) {
                console.log('✅ 从 DOM 中找到地区名称:', nameFromDOM);
                return nameFromDOM;
            }
            return `地区ID:${areaId}`;
        }

        const areaTree = window.vueAppInstance.areaTree.value || [];
        if (areaTree.length === 0) {
            console.warn('⚠️ 地区树数据为空');
            // 尝试通过API获取地区名称
            try {
                // ========== 问题修复：使用统一API调用 ==========
                const areaInfo = await getAreaByIdUnified(areaId);
                if (areaInfo && areaInfo.displayName) {
                    return areaInfo.displayName;
                }
                // ========== 问题修复结束 ==========
            } catch (apiError) {
                console.warn('⚠️ API获取地区名称失败:', apiError);
            }

            // 尝试从 DOM 中查找
            const nameFromDOM = findAreaNameFromDOM(areaId);
            if (nameFromDOM && !nameFromDOM.includes('地区ID:')) {
                console.log('✅ 从 DOM 中找到地区名称:', nameFromDOM);
                return nameFromDOM;
            }
            return `地区ID:${areaId}`;
        }

        console.log('🌳 地区树数据可用，省份数量:', areaTree.length);

        // 递归查找地区，支持多种名称字段的回退机制
        function searchArea(nodes, level = 1) {
            for (const node of nodes) {
                if (node.id == areaId) {
                    console.log(`✅ 找到地区: ${node.name} (级别: ${level})`);

                    // 支持多种名称字段的回退机制
                    let displayName = node.name || node.fullName || node.areaName;

                    // 根据区域级别构造更完整的名称
                    if (level === 3 && node.districtName) {
                        // 区县级：显示省市区全名
                        const provinceName = node.provinceName || node.name;
                        const cityName = node.cityName || '';
                        const districtName = node.districtName || node.name;
                        displayName = `${provinceName}-${cityName}-${districtName}`;
                    } else if (level === 2 && node.cityName) {
                        // 市级：显示省市名
                        const provinceName = node.provinceName || '';
                        const cityName = node.cityName || node.name;
                        displayName = `${provinceName}-${cityName}`;
                    } else if (level === 1 && node.provinceName) {
                        // 省级：显示省名
                        displayName = node.provinceName || node.name;
                    }

                    return displayName || node.name || `地区ID:${areaId}`;
                }
                if (node.children && node.children.length > 0) {
                    const result = searchArea(node.children, level + 1);
                    if (result) return result;
                }
            }
            return null;
        }

        const areaName = searchArea(areaTree);
        if (areaName) {
            return areaName;
        } else {
            console.warn(`⚠️ 未找到地区ID ${areaId} 对应的地区名称`);
            // 最后尝试通过API获取地区名称
            try {
                // ========== 问题修复：使用统一API调用 ==========
                const areaInfo = await getAreaByIdUnified(areaId);
                if (areaInfo && areaInfo.displayName) {
                    return areaInfo.displayName;
                }
                // ========== 问题修复结束 ==========
            } catch (apiError) {
                console.warn('⚠️ API获取地区名称失败:', apiError);
            }

            // 最后尝试从 DOM 中查找
            const nameFromDOM = findAreaNameFromDOM(areaId);
            if (nameFromDOM && !nameFromDOM.includes('地区ID:')) {
                console.log('✅ 从 DOM 中找到地区名称:', nameFromDOM);
                return nameFromDOM;
            }
            return `地区ID:${areaId}`;
        }
    }

    /**
     * 从 DOM 中查找地区名称（回退机制）
     */
    function findAreaNameFromDOM(areaId) {
        try {
            // 遍历已显示的地区配置，查找对应的地区名称
            const areaTags = document.querySelectorAll('.area-tag');
            for (const tag of areaTags) {
                const tagText = tag.textContent.trim();

                // 检查是否包含指定的地区ID
                if (tag.getAttribute('data-area-id') == areaId) {
                    // 直接从 data 属性匹配
                    return tagText;
                } else if (tagText.includes(`地区ID:${areaId}`)) {
                    // 从文本中匹配
                    return tagText;
                }
            }
        } catch (error) {
            console.warn('⚠️ 从 DOM 查找地区名称失败:', error);
        }
        return null;
    }

    /**
     * 从Vue实例的地区树中查找地区名称
     */
    function findAreaNameFromVueTree(areaId) {
        try {
            if (!window.vueAppInstance || !window.vueAppInstance.areaTree) {
                console.warn('⚠️ Vue实例或地区树不可用');
                return null;
            }

            const areaIdNum = parseInt(areaId);
            if (isNaN(areaIdNum)) {
                console.warn('⚠️ 无效的地区ID:', areaId);
                return null;
            }

            // 递归搜索地区树
            function searchTree(nodes) {
                for (const node of nodes) {
                    if (node.id === areaIdNum) {
                        // 根据地区级别构造完整名称
                        if (node.level === 3 && node.districtName) {
                            return `${node.provinceName || ''}-${node.cityName || ''}-${node.districtName || node.name}`;
                        } else if (node.level === 2 && node.cityName) {
                            return `${node.provinceName || ''}-${node.cityName || node.name}`;
                        } else if (node.level === 1 && node.provinceName) {
                            return node.provinceName || node.name;
                        }
                        return node.name || node.areaName || node.fullName;
                    }

                    if (node.children && node.children.length > 0) {
                        const result = searchTree(node.children);
                        if (result) return result;
                    }
                }
                return null;
            }

            return searchTree(window.vueAppInstance.areaTree);
        } catch (error) {
            console.warn('⚠️ 从Vue树查找地区名称失败:', error);
            return null;
        }
    }

    /**
     * 从Vue实例的地区树中查找地区名称
     */
    function findAreaNameFromVueTree(areaId) {
        try {
            if (!window.vueAppInstance || !window.vueAppInstance.areaTree) {
                console.warn('⚠️ Vue实例或地区树不可用');
                return null;
            }

            const areaIdNum = parseInt(areaId);
            if (isNaN(areaIdNum)) {
                console.warn('⚠️ 无效的地区ID:', areaId);
                return null;
            }

            // 递归搜索地区树
            function searchTree(nodes) {
                for (const node of nodes) {
                    if (node.id === areaIdNum) {
                        // 根据地区级别构造完整名称
                        if (node.level === 3 && node.districtName) {
                            return `${node.provinceName || ''}-${node.cityName || ''}-${node.districtName || node.name}`;
                        } else if (node.level === 2 && node.cityName) {
                            return `${node.provinceName || ''}-${node.cityName || node.name}`;
                        } else if (node.level === 1 && node.provinceName) {
                            return node.provinceName || node.name;
                        }
                        return node.name || node.areaName || node.fullName;
                    }

                    if (node.children && node.children.length > 0) {
                        const result = searchTree(node.children);
                        if (result) return result;
                    }
                }
                return null;
            }

            return searchTree(window.vueAppInstance.areaTree);
        } catch (error) {
            console.warn('⚠️ 从Vue树查找地区名称失败:', error);
            return null;
        }
    }

    /**
     * 检查地区是否重复（策略+地区唯一性校验）
     */
    async function checkAreaDuplicate(strategyId, selectedAreaIds) {
        console.log('🔍 检查地区重复性，策略ID:', strategyId, '选中地区:', selectedAreaIds);

        try {
            const duplicateAreaIds = [];
            const allDisplayedAreaIds = new Set();

            // 方法1：通过后端API获取当前策略下已有的地区ID
            try {
                console.log('📡 正在从后端获取已有地区配置...');
                // ========== 问题修复：使用统一API调用 ==========
                const result = await unifiedApiCall(
                    'getStrategyAreaPricingList',
                    '/strategy-area-pricing/list',
                    {strategyId: strategyId}
                );
                // ========== 问题修复结束 ==========
                if (result.code === 0 && result.data) {
                    // 从后端数据中提取所有已使用的地区ID
                    for (const pricing of result.data) {
                        if (pricing.areaIds && pricing.areaIds.length > 0) {
                            pricing.areaIds.forEach(areaId => {
                                allDisplayedAreaIds.add(parseInt(areaId));
                                // console.log('📍 后端数据-已使用地区ID:', areaId, '配置ID:', pricing.id);
                            });
                        }
                    }
                }
            } catch (apiError) {
                console.warn('⚠️ 后端API获取地区配置失败，回退到DOM解析:', apiError);

                // 回退方法：从DOM中解析
                const areaPricingRows = document.querySelectorAll('#area-pricing-list tr[data-pricing-id]');
                areaPricingRows.forEach(row => {
                    const pricingId = row.getAttribute('data-pricing-id');
                    console.log('📋 DOM解析-检查配置行:', pricingId);

                    // 跳过当前正在编辑的配置行（编辑模式下）
                    const isCurrentEditing = window.V3StrategyEditModal &&
                        window.V3StrategyEditModal.currentEditingPricingId === pricingId;
                    if (isCurrentEditing) {
                        console.log('⚠️ 跳过当前编辑的配置行:', pricingId);
                        return;
                    }

                    // 获取该配置下的地区信息
                    const areaElements = row.querySelectorAll('.area-tag');
                    areaElements.forEach(areaElement => {
                        const areaText = areaElement.textContent.trim();
                        console.log('🔍 DOM解析-分析地区文本:', areaText);

                        // 从area-tag的data属性中获取地区ID（如果有）
                        let areaId = areaElement.getAttribute('data-area-id');

                        // 如果是"地区ID:123"格式，直接提取
                        if (!areaId && areaText.includes('地区ID:')) {
                            const match = areaText.match(/地区ID:(\d+)/);
                            if (match) {
                                areaId = parseInt(match[1]);
                            }
                        }

                        if (areaId) {
                            allDisplayedAreaIds.add(parseInt(areaId));
                            console.log('📍 DOM解析-已使用地区ID:', areaId, '来源配置:', pricingId, '地区文本:', areaText);
                        } else {
                            console.warn('⚠️ DOM解析-无法提取地区ID，地区文本:', areaText);
                        }
                    });
                });
            }

            // 同时检查暂存的新增配置
            if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.size > 0) {
                window.pendingNewAreaConfigs.forEach((config, tempId) => {
                    if (config.selectedAreaIds && config.selectedAreaIds.length > 0) {
                        config.selectedAreaIds.forEach(areaId => {
                            allDisplayedAreaIds.add(parseInt(areaId));
                            console.log('📍 暂存配置已使用地区ID:', areaId, '临时ID:', tempId);
                        });
                    }
                });
            }

            console.log('🔍 所有已使用的地区ID:', Array.from(allDisplayedAreaIds));
            console.log('🔍 准备检查的新地区ID:', selectedAreaIds);

            // 检查新选择的地区是否与已显示的地区重复
            for (const areaId of selectedAreaIds) {
                if (allDisplayedAreaIds.has(parseInt(areaId))) {
                    duplicateAreaIds.push(areaId);
                    console.log('❌ 发现重复地区ID:', areaId);
                }
            }

            if (duplicateAreaIds.length > 0) {
                // 发现重复的地区，返回重复的地区信息
                const duplicateAreaNames = [];
                for (const areaId of duplicateAreaIds) {
                    const areaName = await findAreaNameById(areaId) || `地区ID:${areaId}`;
                    duplicateAreaNames.push(`${areaName}(当前策略已有配置)`);
                }

                console.log('❌ 检测到重复地区:', duplicateAreaNames);
                return {
                    hasDuplicate: true,
                    duplicateAreas: duplicateAreaNames,
                    message: `以下地区在当前策略下已有配置，不能重复添加：\n${duplicateAreaNames.join('\n')}`
                };
            }

            console.log('✅ 地区重复性检查通过');
            return {hasDuplicate: false};

        } catch (error) {
            console.error('❌ 地区重复性检查异常:', error);
            return {
                hasDuplicate: false,
                error: true,
                message: '地区重复性检查异常，请谨慎操作'
            };
        }
    }

    /**
     * 从地区文本中提取地区ID
     */
    function extractAreaIdFromText(areaText) {
        // 如果是"地区ID:123"格式，直接提取ID
        const idMatch = areaText.match(/地区ID:(\d+)/);
        if (idMatch) {
            return parseInt(idMatch[1]);
        }

        // 否则通过地区名称反向查找ID
        return findAreaIdByName(areaText);
    }

    /**
     * 根据地区名称查找地区ID
     */
    function findAreaIdByName(areaName) {
        if (!window.vueAppInstance || !window.vueAppInstance.areaTree) {
            return null;
        }

        const areaTree = window.vueAppInstance.areaTree.value || [];

        function searchAreaByName(nodes) {
            for (const node of nodes) {
                // 检查多种名称匹配
                if (node.name === areaName ||
                    node.fullName === areaName ||
                    node.areaName === areaName ||
                    node.provinceName === areaName ||
                    node.cityName === areaName ||
                    node.districtName === areaName) {
                    return node.id;
                }

                // 检查组合名称
                if (node.provinceName && node.cityName && node.districtName) {
                    const fullName = `${node.provinceName}-${node.cityName}-${node.districtName}`;
                    if (fullName === areaName) {
                        return node.id;
                    }
                }

                if (node.provinceName && node.cityName) {
                    const cityFullName = `${node.provinceName}-${node.cityName}`;
                    if (cityFullName === areaName) {
                        return node.id;
                    }
                }

                if (node.children && node.children.length > 0) {
                    const result = searchAreaByName(node.children);
                    if (result) return result;
                }
            }
            return null;
        }

        return searchAreaByName(areaTree);
    }

    /**
     * 渲染重量区间表格
     */
    function renderWeightRulesTable(data) {
        const tbody = document.getElementById('weight-rules-list');
        if (!tbody) return;

        if (!data || data.length === 0) {
            tbody.innerHTML = `
                <tr>
                    <td colspan="4" class="empty-cell">
                        <div class="empty-state">
                            <i class="icon-weight"></i>
                            <p>暂无重量区间配置</p>
                            <p class="empty-hint">重量区间适用于进阶计费模式</p>
                            <button class="btn btn-secondary btn-small" onclick="window.V3StrategyEditModal.addWeightRule()">
                                添加第一个区间规则
                            </button>
                        </div>
                    </td>
                </tr>
            `;
            return;
        }

        tbody.innerHTML = data.map(item => `
            <tr data-rule-id="${item.id}">
                <td>
                    <select class="table-select pricing-select" 
                            data-field="pricingId" data-id="${item.id}" 
                            data-current-pricing="${item.pricingId || ''}" 
                            onchange="handlePricingChange(this)">
                        <option value="">请选择地区配置</option>
                        <!-- 动态加载地区配置选项 -->
                    </select>
                </td>
                <td>
                    <input type="number" value="${item.upperBound}" 
                           step="0.1" min="0" class="table-input weight-input" 
                           data-field="upperBound" data-id="${item.id}">
                </td>
                <td>
                    <input type="number" value="${item.freight}" 
                           step="0.1" min="0" class="table-input fee-input" 
                           data-field="freight" data-id="${item.id}">
                </td>
                <td>
                    <div class="action-buttons">
                        <button class="btn-small btn-danger" 
                                onclick="deleteWeightRule(${item.id})" 
                                title="删除规则">
                            <i class="icon-delete"></i> 删除
                        </button>
                    </div>
                </td>
            </tr>
        `).join('');

        // 绑定输入框变化事件
        bindTableInputEvents();

        // 初始化地区配置下拉选项（使用延迟确保 DOM 完全渲染）
        setTimeout(() => {
            initPricingSelectOptions();
        }, 100);
    }

    /**
     * 初始化地区配置下拉选项
     */
    async function initPricingSelectOptions() {
        try {
            // 获取当前策略的地区配置数据
            if (!window.V3StrategyEditModal || !window.V3StrategyEditModal.currentStrategy) {
                console.warn('⚠️ 未找到当前策略信息，无法初始化下拉选项');
                return;
            }

            const strategy = window.V3StrategyEditModal.currentStrategy;
            console.log('📋 初始化地区配置下拉选项，策略ID:', strategy.id);

            // 1. 加载数据库中已保存的配置
            const areaPricingData = await loadStrategyAreaPricingData(strategy.id);

            // 2. 合并数据库配置和暂存配置，根据项目规范
            const allPricingOptions = [...areaPricingData];

            // 3. 添加暂存的新增配置（window.pendingNewAreaConfigs）
            if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.size > 0) {
                window.pendingNewAreaConfigs.forEach((config, tempId) => {
                    allPricingOptions.push({
                        id: tempId,
                        name: config.name || '未命名配置',
                        isPending: true
                    });
                });
                console.log('🔄 合并暂存配置，总数:', allPricingOptions.length);
            }

            const pricingSelects = document.querySelectorAll('.pricing-select');

            console.log('🗒️ 找到', pricingSelects.length, '个下拉框，地区配置数据:', allPricingOptions.length, '条');

            pricingSelects.forEach(select => {
                // 保存当前选中的值和显示的文本
                const currentValue = select.value;
                const currentDisplayText = select.selectedOptions[0]?.textContent;

                // 清空现有选项（保留默认选项）
                while (select.children.length > 1) {
                    select.removeChild(select.lastChild);
                }

                // 添加地区配置选项（包括已保存的和暂存的）
                allPricingOptions.forEach(pricing => {
                    const option = document.createElement('option');
                    option.value = pricing.id;
                    // 只显示配置名称，不显示地区信息
                    let displayName = pricing.name || '未命名配置';
                    if (pricing.isPending) {
                        displayName += ' (暂存)';
                        // 为暂存配置添加 data-temp-id 属性，用于重量规则关联
                        option.setAttribute('data-temp-id', pricing.id);
                    }
                    option.textContent = displayName;
                    select.appendChild(option);
                });

                // 恢复之前选中的值（如果该选项仍然存在）
                if (currentValue && currentValue !== '') {
                    // 检查该选项是否还存在
                    const optionExists = Array.from(select.options).some(option => option.value === currentValue);
                    if (optionExists) {
                        select.value = currentValue;
                        console.log('🔄 恢复下拉框选中值:', currentValue, '显示文本:', currentDisplayText);

                        // 如果是新添加的规则（临时ID），保持原有的配置名称显示
                        const ruleId = select.getAttribute('data-id');
                        if (ruleId && parseInt(ruleId) < 0) {
                            // 对于临时规则，确保选项文本保持最新的配置名称
                            const selectedOption = select.selectedOptions[0];
                            if (selectedOption && currentDisplayText && selectedOption.textContent !== currentDisplayText) {
                                selectedOption.textContent = currentDisplayText;
                                console.log('🔧 为临时规则保持配置名称显示:', currentDisplayText);
                            }
                        }
                    } else {
                        console.log('⚠️ 选项不存在，无法恢复选中值:', currentValue);
                    }
                } else {
                    // 如果没有之前的选中值，尝试从data属性获取
                    const currentPricingId = select.getAttribute('data-current-pricing');
                    if (currentPricingId && currentPricingId !== '') {
                        const optionExists = Array.from(select.options).some(option => option.value === currentPricingId);
                        if (optionExists) {
                            select.value = currentPricingId;
                            console.log('🎯 从data属性设置下拉框选中值:', currentPricingId);
                        }
                    }
                }
            });

            console.log('✅ 地区配置下拉选项初始化完成');
        } catch (error) {
            console.error('❗ 初始化地区配置选项失败:', error);
            showMessage('加载地区配置选项失败: ' + error.message, true);
        }
    }

    /**
     * 处理地区配置选择变化
     */
    window.handlePricingChange = async function (selectElement) {
        const pricingId = selectElement.value;
        const ruleId = selectElement.getAttribute('data-id');

        if (!pricingId) {
            return;
        }

        // 检查是否选择的是暂存配置（ID以temp_开头）
        if (typeof pricingId === 'string' && pricingId.startsWith('temp_')) {
            console.log('🔄 选择的是暂存配置，不调用后端接口，仅更新前端状态:', pricingId);
            // 更新显示的地区名称，并保存到数据属性中
            const selectedOption = selectElement.selectedOptions[0];
            if (selectedOption) {
                const configName = selectedOption.textContent;
                selectElement.setAttribute('data-area-name', configName);
                selectElement.setAttribute('data-selected-config-name', configName);
                console.log('📝 为重量规则保存暂存配置名称:', configName);
            }
            // 标记为已修改，交给"保存所有配置"按钮统一处理
            selectElement.classList.add('modified');
            // showMessage('暂存配置已选择，请点击"保存所有配置"按钮统一保存');
            return;
        }

        // 检查是否为新添加的临时规则（负数ID）
        if (parseInt(ruleId) < 0) {
            console.log('🔄 临时规则不需要更新关联，仅更新显示');
            // 更新显示的地区名称，并保存到数据属性中以便后续恢复
            const selectedOption = selectElement.selectedOptions[0];
            if (selectedOption) {
                const configName = selectedOption.textContent;
                selectElement.setAttribute('data-area-name', configName);
                selectElement.setAttribute('data-selected-config-name', configName);
                console.log('📝 为临时规则保存配置名称:', configName);
            }
            // 标记为已修改，以便保存时处理
            selectElement.classList.add('modified');
            showMessage('地区配置已选择，请点击“保存”按钮保存新规则');
            return;
        }

        try {
            // 首先获取现有的重量规则数据
            const existingRule = await getCurrentWeightRule(ruleId);
            if (!existingRule) {
                throw new Error('无法获取重量规则数据');
            }

            // 更新重量区间规则的pricing_id（使用现有的update接口）
            const updateData = {
                id: parseInt(ruleId),
                strategyId: existingRule.strategyId,
                pricingId: parseInt(pricingId),
                upperBound: existingRule.upperBound,
                freight: existingRule.freight,
                operator: 'admin'
            };

            console.log('🔄 更新重量规则关联，数据:', updateData);

            // ========== 问题修复：使用统一API调用 ==========
            const result = await unifiedApiCall(
                'updateWeightRule',
                '/weight-segment-rule/update',
                updateData
            );
            // ========== 问题修复结束 ==========
            if (result.code === 0) {
                showMessage('地区配置关联成功');

                // 更新显示的地区名称，并保存到数据属性中
                const selectedOption = selectElement.selectedOptions[0];
                if (selectedOption) {
                    const configName = selectedOption.textContent;
                    selectElement.setAttribute('data-area-name', configName);
                    selectElement.setAttribute('data-selected-config-name', configName);
                    console.log('📝 为正式规则保存配置名称:', configName);
                }
            } else {
                throw new Error(result.msg || '关联失败');
            }
        } catch (error) {
            console.error('更新地区配置关联失败:', error);
            showMessage('关联失败: ' + error.message, true);
        }
    };

    /**
     * 获取当前重量规则数据
     */
    async function getCurrentWeightRule(ruleId) {
        try {
            // 优先从模态框上下文获取策略信息
            let currentStrategy = null;
            if (window.V3StrategyEditModal && window.V3StrategyEditModal.currentStrategy) {
                currentStrategy = window.V3StrategyEditModal.currentStrategy;
            } else if (state.selectedStrategy) {
                currentStrategy = state.selectedStrategy;
            }

            if (!currentStrategy || !currentStrategy.id) {
                console.warn('无法获取当前策略信息');
                return null;
            }

            console.log('🔍 使用策略:', currentStrategy.id, '查找重量规则:', ruleId);

            // 从当前加载的重量规则数据中查找
            const weightRulesData = await loadStrategyWeightRulesData(currentStrategy.id);
            console.log('📊 加载到重量规则数据:', weightRulesData);

            const rule = weightRulesData.find(r => r.id == ruleId);
            if (rule) {
                console.log('✅ 找到重量规则:', rule);
                return {
                    strategyId: currentStrategy.id,
                    upperBound: rule.upperBound,
                    freight: rule.freight
                };
            } else {
                console.warn('⚠️ 未找到指定的重量规则:', ruleId);
                return null;
            }
        } catch (error) {
            console.error('获取重量规则数据失败:', error);
            return null;
        }
    }

    /**
     * 绑定表格输入框事件
     */
    function bindTableInputEvents() {
        // 绑定所有 table-input 类的输入框
        const inputs = document.querySelectorAll('#strategy-edit-modal .table-input');
        inputs.forEach(input => {
            // 移除已存在的事件监听器，防止重复绑定
            input.removeEventListener('change', handleInputChange);
            input.removeEventListener('focus', handleInputFocus);
            input.removeEventListener('blur', handleInputBlur);

            // 绑定新的事件监听器
            input.addEventListener('change', handleInputChange);
            input.addEventListener('focus', handleInputFocus);
            input.addEventListener('blur', handleInputBlur); // 新增：失去焦点时验证
        });

        // 特别处理配置名称输入框（这些使用 onchange 属性，确保也能标记为 modified）
        const nameInputs = document.querySelectorAll('#strategy-edit-modal .name-input');
        nameInputs.forEach(input => {
            // 移除已存在的事件监听器，防止重复绑定
            input.removeEventListener('input', handleInputChange);
            input.removeEventListener('change', handleInputChange);
            input.removeEventListener('focus', handleInputFocus);

            // 绑定新的事件监听器（使用 input 事件实时响应）
            input.addEventListener('input', handleInputChange);
            input.addEventListener('change', handleInputChange);
            input.addEventListener('focus', handleInputFocus);
        });
    }

    /**
     * 加载策略地区定价数据
     */
    async function loadStrategyAreaPricingData(strategyId) {
        try {
            console.log('📊 开始加载地区定价数据, 策略ID:', strategyId);

            // ========== 问题修复：使用统一API调用 ==========
            const result = await unifiedApiCall(
                'getStrategyAreaPricingList',
                '/strategy-area-pricing/list',
                {strategyId: strategyId}
            );
            // ========== 问题修复结束 ==========
            console.log('📄 地区定价数据响应:', result);

            if (result.code === 0) {
                // 后端已经返回包含区域名称的完整数据，直接处理
                const processedData = (result.data || []).map(item => {
                    return {
                        id: item.id,
                        name: item.name || '未命名定价',
                        areas: item.areaNames || [], // 后端已经提供了区域名称列表
                        areaCount: item.areaCount || 0,
                        status: item.status || 1,
                        description: item.description || '',
                        strategyId: item.strategyId,
                        firstWeightKg: item.firstWeightKg,
                        firstWeightFee: item.firstWeightFee,
                        additionalWeightKg: item.additionalWeightKg,
                        additionalWeightFee: item.additionalWeightFee,
                        volumetricWeightRatio: item.volumetricWeightRatio || 0, // 修复：添加抛重比字段映射
                        createTime: item.createTime
                    };
                });
                console.log('✅ 处理后的地区定价数据:', processedData);
                return processedData;
            } else {
                console.error('❌ API返回错误:', result);
                throw new Error(result.msg || '查询地区定价数据失败');
            }
        } catch (error) {
            console.error('❌ 加载地区定价数据失败:', error);
            throw error;
        }
    }

    /**
     * 加载策略重量区间规则数据 - 从策略区域定价接口获取
     */
    async function loadStrategyWeightRulesData(strategyId) {
        try {
            console.log('📊 开始加载重量规则数据, 策略ID:', strategyId);

            // 使用统一的策略区域定价接口获取重量规则
            const result = await unifiedApiCall(
                'getStrategyAreaPricingList',
                '/strategy-area-pricing/list',
                {strategyId: strategyId}
            );
            console.log('📄 重量区间规则数据响应:', result);

            if (result.code === 0) {
                // 从策略区域配置数据中提取重量规则
                const processedData = [];
                (result.data || []).forEach(item => {
                    if (item.weightSegmentRules && Array.isArray(item.weightSegmentRules)) {
                        item.weightSegmentRules.forEach(rule => {
                            const processed = {
                                id: rule.id,
                                pricingId: item.id, // 关联的定价配置ID
                                upperBound: parseFloat(rule.upperBound || 0),
                                freight: parseFloat(rule.freight || 0),
                                // 从关联的strategy_area_pricing表获取首重和续重信息
                                firstWeightKg: parseFloat(item.firstWeightKg || 0),
                                firstWeightFee: parseFloat(item.firstWeightFee || 0),
                                additionalWeightKg: parseFloat(item.additionalWeightKg || 0),
                                additionalWeightFee: parseFloat(item.additionalWeightFee || 0),
                                volumetricWeightRatio: parseFloat(item.volumetricWeightRatio || 0), // 抛重比
                                applyAreas: item.name || '未知地区',
                                status: item.status || 1 // 默认启用
                            };

                            processedData.push(processed);
                            console.log('🔄 处理重量规则数据项:', rule, '->', processed);
                        });
                    }
                });

                console.log('✅ 处理后的重量区间数据:', processedData);
                return processedData;
            } else {
                console.error('❌ API返回错误:', result);
                throw new Error(result.msg || '查询重量区间规则数据失败');
            }
        } catch (error) {
            console.error('❌ 加载重量区间规则数据失败:', error);
            throw error;
        }
    }

    /**
     * 输入框值变化处理
     */
    function handleInputChange(event) {
        const input = event.target;
        const id = input.dataset.id;
        const field = input.dataset.field;
        const value = input.value;

        console.log(`字段 ${field} 更新为: ${value}, ID: ${id}`);

        // 数值字段标记为已修改，但不立即验证（防止与步进控件冲突）
        if (field.includes('Weight') || field.includes('Fee') || field === 'freight' || field === 'upperBound' || field === 'volumetricWeightRatio') {
            input.classList.remove('error'); // 移除之前的错误样式
        }

        // 标记为已修改
        input.classList.add('modified');
    }

    /**
     * 输入框失去焦点时的数值验证
     */
    function handleInputBlur(event) {
        const input = event.target;
        const field = input.dataset.field;
        const value = input.value;

        // 数值验证：不允许负数
        if (field.includes('Weight') || field.includes('Fee') || field === 'freight' || field === 'upperBound' || field === 'volumetricWeightRatio') {
            const numValue = parseFloat(value);
            if (isNaN(numValue) || numValue < 0) {
                const fieldName = getFieldDisplayName(field);
                showMessage(`${fieldName}不能为负数，已自动重置为0`, 'warning');

                // 重置为0
                input.value = '0';
                input.classList.add('error');

                // 2秒后移除错误样式
                setTimeout(() => {
                    input.classList.remove('error');
                }, 2000);

                // 继续标记为已修改，使用重置后的值
                input.classList.add('modified');
            } else {
                input.classList.remove('error');
            }
        }
    }

    /**
     * 获取字段显示名称
     */
    function getFieldDisplayName(field) {
        const fieldNames = {
            'firstWeightKg': '首重重量',
            'firstWeightFee': '首重资费',
            'additionalWeightKg': '续重重量',
            'additionalWeightFee': '续重资费',
            'volumetricWeightRatio': '抛重比',
            'freight': '费用',
            'upperBound': '重量上限'
        };
        return fieldNames[field] || field;
    }

    /**
     * 输入框获取焦点处理
     */
    function handleInputFocus(event) {
        event.target.select();
    }

    /**
     * 区域编辑功能
     */
    function editAreas() {
        if (!state.selectedStrategy) {
            showMessage('请先选择一个策略', true);
            return;
        }

        console.log('编辑区域:', state.selectedStrategy);

        // 获取Vue应用实例
        if (window.vueAppInstance && window.vueAppInstance.openV3AreaSelector) {
            // 设置当前策略 - 添加安全检查
            if (window.vueAppInstance.v3CurrentStrategy) {
                window.vueAppInstance.v3CurrentStrategy.value = state.selectedStrategy;
            } else {
                console.warn('⚠️ v3CurrentStrategy 未初始化');
                return;
            }

            // 初始化区域选择器状态
            window.vueAppInstance.v3AreaState.selectedProvinces.clear();
            window.vueAppInstance.v3AreaState.selectedCities.clear();
            window.vueAppInstance.v3AreaState.selectedDistricts.clear();

            // 设置已选中的区域（如果有）
            if (state.selectedStrategyAreas && state.selectedStrategyAreas.length > 0) {
                state.selectedStrategyAreas.forEach(area => {
                    if (area.level === 1) {
                        window.vueAppInstance.v3AreaState.selectedProvinces.add(area.id);
                        // 不自动展开省份，用户需要手动点击才展示城市
                        // window.vueAppInstance.v3AreaState.expandedProvinces.add(area.id);
                    } else if (area.level === 2) {
                        window.vueAppInstance.v3AreaState.selectedCities.add(area.id);
                        // 不自动展开城市，用户需要手动点击才展示区县
                        // window.vueAppInstance.v3AreaState.expandedCities.add(area.id);
                    } else if (area.level === 3) {
                        window.vueAppInstance.v3AreaState.selectedDistricts.add(area.id);
                    }
                });
            }

            // 显示区域选择器
            window.vueAppInstance.showV3AreaSelector = true;
        } else {
            showMessage('系统初始化未完成，请刷新页面', true);
        }
    }

    /**
     * 计费规则编辑功能
     */
    function editPricingRules() {
        if (!state.selectedStrategy) {
            showMessage('请先选择一个策略', true);
            return;
        }

        console.log('编辑计费规则:', state.selectedStrategy);

        // 获取Vue应用实例
        if (window.vueAppInstance && window.vueAppInstance.openV3PricingRulesModal) {
            // 设置当前策略 - 添加安全检查
            if (window.vueAppInstance.v3CurrentStrategy) {
                window.vueAppInstance.v3CurrentStrategy.value = state.selectedStrategy;
            } else {
                console.warn('⚠️ v3CurrentStrategy 未初始化');
                return;
            }

            // 调用打开计费规则模态框的方法
            window.vueAppInstance.openV3PricingRulesModal();
        } else {
            showMessage('系统初始化未完成，请刷新页面', true);
        }
    }

    /**
     * 初始化模块
     */
    async function init() {
        try {
            console.log('🔄 V3策略配置管理器开始初始化...');

            // 详细的DOM元素检查
            const container = document.getElementById('v3-strategy-config-container');
            const strategyList = document.getElementById('v3-strategy-list');
            const areaDisplay = document.getElementById('v3-area-display');
            const pricingRules = document.getElementById('v3-pricing-rules');

            console.log('🔍 DOM元素检查结果:');
            console.log('  - v3-strategy-config-container:', !!container);
            console.log('  - v3-strategy-list:', !!strategyList);
            console.log('  - v3-area-display:', !!areaDisplay);
            console.log('  - v3-pricing-rules:', !!pricingRules);

            if (!container) {
                console.warn('⚠️ V3策略配置主容器不存在，但继续初始化数据...');
                // 不直接返回，继续加载数据，因为容器可能会在后续DOM更新中出现
            }

            console.log('🔄 开始加载基础数据...');

            // 加载基础数据
            const results = await Promise.allSettled([
                loadStrategies(),
                loadAreaTree()
            ]);

            // 检查加载结果
            if (results[0].status === 'fulfilled') {
                console.log('✅ 策略数据加载成功，数量:', state.strategies.length);
            } else {
                console.warn('⚠️ 策略数据加载失败:', results[0].reason?.message || results[0].reason);
                // 不抛出错误，继续初始化
                state.strategies = [];
            }

            if (results[1].status === 'fulfilled') {
                console.log('✅ 区域数据加载成功，数量:', state.areaTree.length);
            } else {
                console.warn('⚠️ 区域数据加载失败:', results[1].reason?.message || results[1].reason);
                // 区域数据失败不阻塞整个初始化，但记录错误
                state.areaTree = [];
            }

            // 尝试渲染初始界面
            console.log('🎨 尝试渲染初始界面...');
            try {
                renderStrategyConfig();
                console.log('✅ 初始界面渲染完成');
            } catch (renderError) {
                console.warn('⚠️ 初始界面渲染失败（可能是容器不存在）:', renderError.message);
                // 渲染失败不阻塞初始化，数据已加载
            }

            console.log('✅ V3策略配置管理模块初始化完成');

            // 触发初始化完成事件
            window.dispatchEvent(new CustomEvent('v3StrategyConfigReady', {
                detail: {
                    strategiesCount: state.strategies.length,
                    areasCount: state.areaTree.length
                }
            }));

        } catch (error) {
            console.error('❌ V3策略配置管理模块初始化失败:', error);
            console.error('错误详情:', error.stack);

            // 即使初始化失败，也不阻塞整个应用
            showMessage('策略管理模块初始化失败，但不影响其他功能使用', true);

            // 触发初始化失败事件，但不抛出错误
            window.dispatchEvent(new CustomEvent('v3StrategyConfigError', {
                detail: {
                    error: error.message,
                    degradedMode: true
                }
            }));

            // 不再重新抛出错误，让应用继续运行
            console.warn('⚠️ V3策略配置模块以降级模式运行');
        }
    }

    // ================================ 公开API ================================
    console.log('🚀 [调试] 准备返回API对象...');
    const apiObject = {
        // 初始化
        init,

        // 数据操作
        selectStrategy,
        editStrategy,
        editAreas,
        editPricingRules,

        // 保存方法 - 通过引用访问 V3StrategyEditModal 中的方法
        saveAreaPricingConfigV2: function (strategyId) {
            if (window.V3StrategyEditModal && window.V3StrategyEditModal.saveAreaPricingConfigV2) {
                return window.V3StrategyEditModal.saveAreaPricingConfigV2(strategyId);
            } else {
                showMessage('保存功能未准备就绪，请先打开策略编辑界面', true);
            }
        },
        buildAreaConfigFromRow: function (row, strategyId) {
            if (window.V3StrategyEditModal && window.V3StrategyEditModal.buildAreaConfigFromRow) {
                return window.V3StrategyEditModal.buildAreaConfigFromRow(row, strategyId);
            } else {
                console.warn('buildAreaConfigFromRow 功能未准备就绪');
                return null;
            }
        },

        // 状态获取
        getState: () => state,
        getSelectedStrategy: () => state.selectedStrategy,
        getSelectedAreas: () => state.selectedStrategyAreas,

        // 校验方法
        checkAreaDuplicate: checkAreaDuplicate,
        findAreaNameById: findAreaNameById,
        findAreaIdByName: findAreaIdByName,

        // 工具方法
        formatDate,
        formatMoney,
        showMessage
    };

    console.log('🚀 [调试] API对象已创建，包含方法:', Object.keys(apiObject));
    console.log('🚀 [调试] 返回API对象...');

    return apiObject;
})();

// ==================== 调试：模块加载结果 ====================
console.log('🎉 [调试] IIFE执行完成！');
console.log('🎉 [调试] window.V3StrategyConfigManager 存在:', !!window.V3StrategyConfigManager);
console.log('🎉 [调试] 模块类型:', typeof window.V3StrategyConfigManager);
if (window.V3StrategyConfigManager) {
    console.log('🎉 [调试] 模块方法:', Object.keys(window.V3StrategyConfigManager));
    console.log('🎉 [调试] init方法类型:', typeof window.V3StrategyConfigManager.init);
} else {
    console.error('❌ [调试] 模块赋值失败！');
}

// ============================= 立即验证模块加载 =============================

(function () {
    'use strict';

    // 立即检查模块是否正确加载
    console.log('🔍 V3StrategyConfigManager模块加载检查:');
    console.log('  - window.V3StrategyConfigManager 存在:', !!window.V3StrategyConfigManager);
    console.log('  - 模块类型:', typeof window.V3StrategyConfigManager);

    if (window.V3StrategyConfigManager) {
        console.log('  - init方法存在:', typeof window.V3StrategyConfigManager.init);
        console.log('  - selectStrategy方法存在:', typeof window.V3StrategyConfigManager.selectStrategy);
        console.log('  - 可用方法:', Object.keys(window.V3StrategyConfigManager));
        console.log('✅ V3StrategyConfigManager模块加载成功');
    } else {
        console.error('❌ V3StrategyConfigManager模块加载失败');
    }

    // 触发模块加载完成事件
    setTimeout(() => {
        window.dispatchEvent(new CustomEvent('v3ModuleLoaded', {
            detail: {
                loaded: !!window.V3StrategyConfigManager,
                timestamp: new Date().toISOString()
            }
        }));
        console.log('📡 v3ModuleLoaded 事件已触发');
    }, 10);
})();

// ================================ 全局辅助函数已在DOMContentLoaded中直接定义 ================================

// ================================ 全局函数暴露（立即执行） ================================

/**
 * 立即暴露函数到全局作用域，不等待任何事件
 */
(function () {
    'use strict';

    console.log('🔧 开始立即暴露全局函数...');

    // 直接定义并暴露函数
    window.closeStrategyEditModal = function () {
        console.log('🔧 closeStrategyEditModal 被调用');

        // ========== 问题修复：清理暂存数据，防止重复 ==========
        try {
            // 清理暂存的新增地区配置
            if (window.pendingNewAreaConfigs) {
                console.log('🧹 清理暂存的新增地区配置，数量:', window.pendingNewAreaConfigs.size);
                window.pendingNewAreaConfigs.clear();
            }

            // 清理暂存的地区变更
            if (window.pendingAreaChanges) {
                console.log('🧹 清理暂存的地区变更，数量:', window.pendingAreaChanges.size);
                window.pendingAreaChanges.clear();
            }

            // 清理编辑状态
            if (window.V3StrategyEditModal) {
                window.V3StrategyEditModal.currentEditingPricingId = null;
                window.V3StrategyEditModal.currentStrategy = null;
                console.log('🧹 清理编辑状态');
            }

            // 清理Vue实例中的地区选择状态
            if (window.vueAppInstance && window.vueAppInstance.v3AreaState) {
                window.vueAppInstance.v3AreaState.selectedProvinces.clear();
                window.vueAppInstance.v3AreaState.selectedCities.clear();
                window.vueAppInstance.v3AreaState.selectedDistricts.clear();
                window.vueAppInstance.v3AreaState.expandedProvinces.clear();
                window.vueAppInstance.v3AreaState.expandedCities.clear();
                console.log('🧹 清理Vue地区选择状态');
            }

            console.log('✅ 暂存数据清理完成');
        } catch (error) {
            console.error('❌ 清理暂存数据时出错:', error);
        }
        // ========== 问题修复结束 ==========

        const modal = document.getElementById('strategy-edit-modal');
        if (modal) {
            modal.remove();
            console.log('✅ 策略编辑模态框已关闭');
        } else {
            console.log('⚠️ 未找到策略编辑模态框');
        }
    };

    window.saveStrategyEdit = async function (strategyId) {
        console.log('🔧 saveStrategyEdit 被调用，strategyId:', strategyId);
        try {
            const formData = {
                id: strategyId,
                name: document.getElementById('edit-strategy-name')?.value || '',
                description: document.getElementById('edit-strategy-description')?.value || '',
                pricingModel: parseInt(document.getElementById('edit-strategy-pricing-model')?.value || '1')
            };

            if (!formData.name.trim()) {
                alert('请输入策略名称');
                return;
            }

            console.log('📤 准备保存策略数据:', formData);

            // ========== 问题修复：使用统一API调用 ==========
            const result = await unifiedApiCall(
                'updateStrategy',
                '/strategy/edit',
                formData
            );
            // ========== 问题修复结束 ==========
            if (result.code === 0) {
                alert('策略保存成功');
                window.closeStrategyEditModal();
                if (window.V3StrategyConfigManager && window.V3StrategyConfigManager.init) {
                    await window.V3StrategyConfigManager.init();
                }
            } else {
                throw new Error(result.msg || '保存失败');
            }
        } catch (error) {
            console.error('❌ 保存策略失败:', error);
            alert('保存失败: ' + error.message);
        }
    };

    window.addAreaPricing = function () {
        console.log('🔧 addAreaPricing 被调用');
        if (window.V3StrategyEditModal && window.V3StrategyEditModal.openAreaSelector) {
            window.V3StrategyEditModal.openAreaSelector();
        } else {
            alert('添加地区定价功能正在开发中...');
        }
    };

    window.editWeightRule = function (ruleId) {
        console.log('🔧 editWeightRule 被调用，ruleId:', ruleId);
        if (window.V3StrategyEditModal && window.V3StrategyEditModal.openWeightRuleEditor) {
            window.V3StrategyEditModal.openWeightRuleEditor(ruleId);
        } else {
            alert('编辑重量规则功能正在开发中...');
        }
    };

    window.deleteWeightRule = function (ruleId) {
        console.log('🔧 deleteWeightRule 被调用，ruleId:', ruleId);
        // if (!confirm('确定要删除这个重量区间规则吗？删除操作将由"保存所有配置"按钮统一处理！')) {
        //     return;
        // }

        if (window.V3StrategyEditModal && window.V3StrategyEditModal.deleteWeightRule) {
            window.V3StrategyEditModal.deleteWeightRule(ruleId);
        } else {
            alert('删除重量规则功能正在开发中...');
        }
    };

    // 验证函数是否正确暴露
    const functions = ['closeStrategyEditModal', 'saveStrategyEdit', 'addAreaPricing', 'editWeightRule', 'deleteWeightRule'];
    let successCount = 0;

    functions.forEach(funcName => {
        if (typeof window[funcName] === 'function') {
            console.log(`✅ ${funcName} 已成功暴露到全局作用域`);
            successCount++;
        } else {
            console.error(`❌ ${funcName} 暴露失败:`, typeof window[funcName]);
        }
    });

    console.log(`🎉 函数暴露完成！成功: ${successCount}/${functions.length}`);

    // 立即触发自定义事件，通知函数已加载
    setTimeout(() => {
        window.dispatchEvent(new CustomEvent('v3FunctionsReady'));
        console.log('📡 v3FunctionsReady 事件已触发');
    }, 50);

})();

/**
 * 页面加载完成后初始化
 */
document.addEventListener('DOMContentLoaded', function () {
    console.log('🔧 页面DOM加载完成，开始初始化...');

    // 再次确保函数已暴露（兜底机制）
    const functions = ['closeStrategyEditModal', 'saveStrategyEdit', 'addAreaPricing', 'editWeightRule', 'deleteWeightRule'];
    let missingFunctions = [];

    functions.forEach(funcName => {
        if (typeof window[funcName] !== 'function') {
            missingFunctions.push(funcName);
        }
    });

    if (missingFunctions.length > 0) {
        console.warn('⚠️ 检测到缺失的函数，重新定义:', missingFunctions);
        // 这里可以添加重新定义的逻辑
    } else {
        console.log('✅ 所有函数在DOM加载后验证正常');
    }

    // 再次触发事件（兜底）
    setTimeout(() => {
        window.dispatchEvent(new CustomEvent('v3FunctionsReady'));
        console.log('📡 DOMContentLoaded 中再次触发 v3FunctionsReady 事件');
    }, 100);

    // 如果当前页面包含V3策略配置相关元素，则初始化
    if (document.getElementById('v3-strategy-config-container')) {
        V3StrategyConfigManager.init();
    }
});

// ============================= 新增的配置名称联动和地区编辑函数 =============================

/**
 * 处理配置名称变化，实现联动更新
 */
window.handleConfigNameChange = function (inputElement) {
    const configId = inputElement.dataset.id;
    const newName = inputElement.value;

    if (!configId || !newName.trim()) {
        return;
    }

    // 标记为已修改
    inputElement.classList.add('modified');

    // 同步更新所有相同 ID 的配置名称输入框
    const allNameInputs = document.querySelectorAll(`input.name-input[data-id="${configId}"]`);
    allNameInputs.forEach(input => {
        if (input !== inputElement) {
            input.value = newName;
            input.classList.add('modified');
        }
    });

    // 更新重量区间配置中的下拉选项文本
    const allSelectOptions = document.querySelectorAll(`select.pricing-select option[value="${configId}"]`);
    allSelectOptions.forEach(option => {
        option.textContent = newName;
    });

    console.log(`配置名称已联动更新: ID=${configId}, 新名称=${newName}`);
};

/**
 * 编辑地区信息
 */
window.editAreaInfo = function (pricingId) {
    console.log('📝 [问题修复] 编辑地区信息, 配置 ID:', pricingId);

    // 调用地区选择器，传递配置 ID 以便在选择后更新对应的配置
    if (window.V3StrategyEditModal && window.V3StrategyEditModal.openAreaSelector) {
        // 记录当前编辑的配置 ID
        window.V3StrategyEditModal.currentEditingPricingId = pricingId;
        // 打开地区选择器
        window.V3StrategyEditModal.openAreaSelector();
    } else {
        // 如果 Vue 应用实例可用，尝试直接调用
        if (window.vueAppInstance && window.vueAppInstance.openV3AreaSelector) {
            // 设置当前编辑的配置 ID
            window.vueAppInstance.currentEditingPricingId = pricingId;
            // 显示 V3 地区选择器
            window.vueAppInstance.showV3AreaSelector = true;
            console.log('通过 Vue 实例打开地区选择器');
        } else {
            showMessage('地区编辑功能暂时不可用，请使用“添加地区”按钮', true);
        }
    }
};

/**
 * 初始化重量区间页面加载时的下拉框数据
 * 解决重量区间配置下拉框无数据的问题
 */
async function initWeightRulesPagePricingOptions() {
    try {
        // 等待策略数据加载
        if (!window.V3StrategyConfigManager || !window.V3StrategyConfigManager.getState) {
            setTimeout(initWeightRulesPagePricingOptions, 100);
            return;
        }

        const state = window.V3StrategyConfigManager.getState();
        if (!state.selectedStrategy) {
            return;
        }

        // 加载地区配置数据
        // ========== 问题修复：使用统一API调用 ==========
        const result = await unifiedApiCall(
            'getStrategyAreaPricingList',
            '/strategy-area-pricing/list',
            {strategyId: state.selectedStrategy.id}
        );
        // ========== 问题修复结束 ==========
        if (result.code !== 0) {
            console.error('加载地区配置数据失败:', result.msg);
            return;
        }

        const areaPricingData = result.data || [];

        // 根据项目规范：合并数据库配置和暂存配置
        const allPricingOptions = [...areaPricingData];

        // 添加暂存的新增配置（window.pendingNewAreaConfigs）
        if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.size > 0) {
            window.pendingNewAreaConfigs.forEach((config, tempId) => {
                allPricingOptions.push({
                    id: tempId,
                    name: config.name || '未命名配置',
                    isPending: true
                });
            });
            console.log('🔄 initWeightRulesPagePricingOptions 合并暂存配置，总数:', allPricingOptions.length);
        }

        const pricingSelects = document.querySelectorAll('.pricing-select');

        pricingSelects.forEach(select => {
            // 清空现有选项（保留默认选项）
            while (select.children.length > 1) {
                select.removeChild(select.lastChild);
            }

            // 添加地区配置选项（包括暂存配置）
            allPricingOptions.forEach(pricing => {
                const option = document.createElement('option');
                option.value = pricing.id;
                let displayName = pricing.name || '未命名配置';
                if (pricing.isPending) {
                    displayName += ' (暂存)';
                }
                option.textContent = displayName;
                select.appendChild(option);
            });

            // 设置当前选中的值
            const currentPricingId = select.getAttribute('data-current-pricing');
            if (currentPricingId) {
                select.value = currentPricingId;
            }
        });

        console.log('重量区间下拉框数据初始化完成');
    } catch (error) {
        console.error('初始化重量区间下拉框数据失败:', error);
    }
}

/**
 * 刷新重量规则下拉框选项
 * 用于在新增地区配置后更新重量规则页面的下拉框数据
 */
window.refreshWeightRulePricingOptions = async function () {
    try {
        console.log('🔄 开始刷新重量规则下拉框选项...');

        // 获取当前策略信息
        let currentStrategy = null;
        if (window.V3StrategyEditModal && window.V3StrategyEditModal.currentStrategy) {
            currentStrategy = window.V3StrategyEditModal.currentStrategy;
        } else if (window.V3StrategyConfigManager && window.V3StrategyConfigManager.getState) {
            const state = window.V3StrategyConfigManager.getState();
            currentStrategy = state.selectedStrategy;
        }

        if (!currentStrategy || !currentStrategy.id) {
            console.warn('⚠️ 未找到当前策略信息，无法刷新下拉框');
            return;
        }

        console.log('📋 当前策略ID:', currentStrategy.id);

        // 重新加载最新的地区配置数据
        // ========== 问题修复：使用统一API调用 ==========
        const result = await unifiedApiCall(
            'getStrategyAreaPricingList',
            '/strategy-area-pricing/list',
            {strategyId: currentStrategy.id}
        );
        // ========== 问题修复结束 ==========
        if (result.code !== 0) {
            console.error('❌ 加载最新地区配置数据失败:', result.msg);
            return;
        }

        const areaPricingData = result.data || [];

        // 合并已保存的数据和暂存的新增配置
        const allPricingOptions = [...areaPricingData];

        // 添加暂存的新增配置到下拉框选项中
        if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.size > 0) {
            console.log('📋 刷新时检测到暂存的新增配置:', window.pendingNewAreaConfigs.size, '个');

            window.pendingNewAreaConfigs.forEach((config, tempId) => {
                allPricingOptions.push({
                    id: tempId,
                    name: config.name || '未命名配置',
                    isPending: true
                });
                console.log('🔄 刷新时添加暂存配置:', tempId, config.name);
            });
        }

        console.log('📊 获取到最新地区配置数据:', allPricingOptions.length, '条（包含暂存', window.pendingNewAreaConfigs?.size || 0, '条）');

        // 更新所有重量规则页面的下拉框
        const pricingSelects = document.querySelectorAll('.pricing-select');
        console.log('🔍 找到', pricingSelects.length, '个下拉框需要更新');

        pricingSelects.forEach((select, index) => {
            // 保存当前选中的值
            const currentValue = select.value;

            // 清空现有选项（保留默认选项）
            while (select.children.length > 1) {
                select.removeChild(select.lastChild);
            }

            // 添加最新的地区配置选项（包括暂存的）
            allPricingOptions.forEach(pricing => {
                const option = document.createElement('option');
                option.value = pricing.id;
                let displayName = pricing.name || '未命名配置';
                if (pricing.isPending) {
                    displayName += ' (暂存)';
                }
                option.textContent = displayName;
                select.appendChild(option);
            });

            // 恢复之前选中的值（如果还存在）
            if (currentValue && allPricingOptions.some(p => p.id == currentValue)) {
                select.value = currentValue;
            }

            console.log(`✅ 下拉框 ${index + 1} 刷新完成，选项数量: ${allPricingOptions.length}`);
        });

        console.log('🎉 重量规则下拉框选项刷新完成！');

    } catch (error) {
        console.error('❌ 刷新重量规则下拉框选项失败:', error);
    }
};

// 当页面中出现重量区间表格时，自动初始化下拉框数据
const observer = new MutationObserver(function (mutations) {
    mutations.forEach(function (mutation) {
        if (mutation.type === 'childList') {
            mutation.addedNodes.forEach(function (node) {
                if (node.nodeType === 1 && node.querySelector && node.querySelector('.pricing-select')) {
                    setTimeout(initWeightRulesPagePricingOptions, 100);
                }
            });
        }
    });
});

// 开始观察DOM变化
if (document.body) {
    observer.observe(document.body, {
        childList: true,
        subtree: true
    });
}

/**
 * 保存新的地区配置
 */
window.saveNewAreaConfig = function (tempId) {
    try {
        console.log('💾 开始保存新的地区配置:', tempId);

        const row = document.querySelector(`tr[data-temp-id="${tempId}"]`);
        if (!row) {
            throw new Error('未找到配置行');
        }

        // 收集表单数据进行验证
        const nameInput = row.querySelector('input[data-field="name"]');
        const firstWeightKgInput = row.querySelector('input[data-field="firstWeightKg"]');
        const firstWeightFeeInput = row.querySelector('input[data-field="firstWeightFee"]');
        const additionalWeightKgInput = row.querySelector('input[data-field="additionalWeightKg"]');
        const additionalWeightFeeInput = row.querySelector('input[data-field="additionalWeightFee"]');
        const descriptionInput = row.querySelector('input[data-field="description"]');

        // 数据验证
        if (!nameInput.value || !nameInput.value.trim()) {
            throw new Error('请输入配置名称');
        }
        if (!firstWeightKgInput.value || parseFloat(firstWeightKgInput.value) < 0) {
            throw new Error('首重不能为空或负数');
        }
        if (!firstWeightFeeInput.value || parseFloat(firstWeightFeeInput.value) < 0) {
            throw new Error('首费不能为空或负数');
        }
        if (!additionalWeightKgInput.value || parseFloat(additionalWeightKgInput.value) < 0) {
            throw new Error('续重不能为空或负数');
        }
        if (!additionalWeightFeeInput.value || parseFloat(additionalWeightFeeInput.value) < 0) {
            throw new Error('续费不能为空或负数');
        }

        console.log('✅ 验证通过，标记新地区配置为已确认:', tempId);

        // 移除暂存状态样式，标记为已确认的新配置
        row.classList.remove('new-area-config');
        row.classList.add('confirmed-new-area-config');

        // 修改操作按钮为显示确认状态
        const actionButtons = row.querySelector('.action-buttons');
        if (actionButtons) {
            actionButtons.innerHTML = `
                <span class="status-text text-success">
                    <i class="icon-check"></i> 已确认，等待保存
                </span>
            `;
        }

        // 标记所有输入框为已修改，但不设置只读（允许继续修改）
        const inputs = row.querySelectorAll('input');
        inputs.forEach(input => {
            input.classList.add('modified');
            // 移除只读限制，允许继续修改
            input.removeAttribute('readonly');
        });

        // 更新暂存配置状态
        if (window.pendingNewAreaConfigs && window.pendingNewAreaConfigs.has(tempId)) {
            const config = window.pendingNewAreaConfigs.get(tempId);
            config.confirmed = true;
            config.name = nameInput.value;
            config.firstWeightKg = parseFloat(firstWeightKgInput.value);
            config.firstWeightFee = parseFloat(firstWeightFeeInput.value);
            config.additionalWeightKg = parseFloat(additionalWeightKgInput.value);
            config.additionalWeightFee = parseFloat(additionalWeightFeeInput.value);
            config.description = descriptionInput.value;

            console.log('✅ 已更新暂存配置状态:', config);
        }

        // 显示成功信息，参考重量区间配置的提示
        showMessage('地区配置已确认，请点击"保存所有配置"按钮进行统一保存', 'success');

        // 刷新重量区间下拉框选项
        if (typeof window.refreshWeightRulePricingOptions === 'function') {
            setTimeout(() => {
                window.refreshWeightRulePricingOptions();
                console.log('✅ 已刷新重量区间下拉框选项');
            }, 300);
        }

    } catch (error) {
        console.error('验证新地区配置失败:', error);
        showMessage('验证失败: ' + error.message, true);
    }
};

/**
 * 取消暂存的地区配置
 */
window.cancelPendingAreaConfig = async function (tempId) {
    if (!window.pendingNewAreaConfigs || !window.pendingNewAreaConfigs.has(tempId)) {
        console.warn('未找到指定的暂存配置:', tempId);
        return;
    }

    // 从暂存列表中移除
    window.pendingNewAreaConfigs.delete(tempId);

    console.log('✅ 已取消暂存配置:', tempId);
    showMessage('已取消暂存的地区配置');

    // 重新渲染表格
    if (window.V3StrategyEditModal && window.V3StrategyEditModal.currentStrategy) {
        try {
            const data = await loadStrategyAreaPricingData(window.V3StrategyEditModal.currentStrategy.id);
            await renderAreaPricingTable(data);
        } catch (error) {
            console.error('重新加载数据失败:', error);
        }
    }
};

// ================================ CSS样式函数 ================================

/**
 * 添加查看模式标签的CSS样式
 */
function addViewModeStyles() {
    // 检查是否已经添加过样式
    if (document.getElementById('v3-view-mode-styles')) {
        return;
    }

    const styles = `
        <style id="v3-view-mode-styles">
            .view-mode-label {
                background: linear-gradient(135deg, #f0f9ff 0%, #e0f2fe 100%);
                color: #1976d2;
                padding: 6px 12px;
                border-radius: 12px;
                font-size: 12px;
                font-weight: 500;
                border: 1px solid #b3d8ff;
                display: inline-flex;
                align-items: center;
                gap: 4px;
                margin-left: auto;
                box-shadow: 0 2px 4px rgba(25, 118, 210, 0.1);
                transition: all 0.2s ease;
            }
            
            .view-mode-label::before {
                content: '👁️';
                font-size: 10px;
            }
            
            .view-mode-label:hover {
                background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%);
                transform: translateY(-1px);
                box-shadow: 0 4px 8px rgba(25, 118, 210, 0.15);
            }
            
            .area-header, .pricing-header {
                display: flex;
                justify-content: space-between;
                align-items: center;
                margin-bottom: 16px;
                padding-bottom: 12px;
                border-bottom: 2px solid var(--color-border-extra-light);
            }
            
            .area-header h4, .pricing-header h4 {
                margin: 0;
                color: var(--color-text-primary);
                font-size: 16px;
                font-weight: 600;
                display: flex;
                align-items: center;
                gap: 8px;
            }
            
            /* 主页面表格样式，与编辑页面保持一致 */
            .area-pricing-table, .weight-rules-table {
                overflow-x: auto;
                border-radius: 8px;
                border: 1px solid var(--color-border-light);
            }
            
            .config-table {
                width: 100%;
                border-collapse: collapse;
                background: white;
                font-size: 13px;
            }
            
            .config-table th {
                background: linear-gradient(135deg, #f8fafc 0%, #f1f5f9 100%);
                color: var(--color-text-primary);
                font-weight: 600;
                padding: 12px 8px;
                text-align: center;
                border: 1px solid var(--color-border-light);
                position: sticky;
                top: 0;
                z-index: 10;
            }
            
            .config-table td {
                padding: 10px 8px;
                border: 1px solid var(--color-border-lighter);
                text-align: center;
                vertical-align: middle;
                background: white;
            }
            
            .config-table tr:hover {
                background-color: #f8f9fa;
            }
            
            .readonly-text {
                display: block;
                width: 100%;
                padding: 6px 8px;
                background: #f8f9fa;
                border: 1px solid #e9ecef;
                border-radius: 4px;
                color: var(--color-text-regular);
                font-size: 13px;
                text-align: center;
            }
            
            .area-info {
                padding: 4px;
            }
            
            .area-tags {
                display: flex;
                flex-wrap: wrap;
                gap: 4px;
                line-height: 1.4;
            }
            
            .area-tag {
                display: inline-block;
                padding: 2px 8px;
                background: linear-gradient(135deg, #e3f2fd 0%, #f0f8ff 100%);
                color: #1976d2;
                border: 1px solid #bbdefb;
                border-radius: 12px;
                font-size: 11px;
                font-weight: 500;
                white-space: nowrap;
                margin: 1px;
                transition: all 0.2s ease;
            }
            
            .area-tag:hover {
                background: linear-gradient(135deg, #bbdefb 0%, #e3f2fd 100%);
                transform: translateY(-1px);
                box-shadow: 0 2px 4px rgba(25, 118, 210, 0.2);
            }
            
            .area-list {
                word-break: break-all;
                line-height: 1.4;
                font-size: 12px;
            }
            
            .blue-text {
                color: var(--color-primary);
            }
            
            .status-badge {
                padding: 4px 12px;
                border-radius: 12px;
                font-size: 11px;
                font-weight: 500;
                border: 1px solid transparent;
                display: inline-block;
            }
            
            .status-active {
                background: linear-gradient(135deg, #67c23a 0%, #85ce61 100%);
                color: white;
                border-color: #5daf34;
            }
            
            .status-inactive {
                background: linear-gradient(135deg, #f56c6c 0%, #f78989 100%);
                color: white;
                border-color: #f15656;
            }
            
            .empty-cell {
                text-align: center;
                padding: 40px 20px;
                background: #fafbfc;
            }
            
            .empty-state {
                display: flex;
                flex-direction: column;
                align-items: center;
                gap: 8px;
                color: var(--color-text-secondary);
            }
            
            .empty-state i {
                font-size: 24px;
                opacity: 0.5;
            }
            
            .error-state {
                text-align: center;
                padding: 20px;
                color: var(--color-danger);
                background: #fef2f2;
                border-radius: 8px;
                margin-top: 16px;
            }
            
            /* 空状态通知样式 */
            .empty-state-notice, .pricing-mode-notice {
                text-align: center;
                padding: 40px 20px;
                background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
                border-radius: 12px;
                margin: 16px 0;
                border: 1px solid #dee2e6;
            }
            
            .notice-content {
                display: flex;
                flex-direction: column;
                align-items: center;
                gap: 12px;
                color: var(--color-text-secondary);
            }
            
            .notice-content i {
                font-size: 32px;
                color: var(--color-info);
                opacity: 0.7;
            }
            
            .notice-content h4 {
                margin: 0;
                color: var(--color-text-primary);
                font-size: 16px;
                font-weight: 600;
            }
            
            .notice-content p {
                margin: 4px 0;
                font-size: 14px;
                line-height: 1.5;
            }
            
            .notice-subtitle {
                color: var(--color-text-placeholder) !important;
                font-size: 12px !important;
            }
            
            .notice-hint {
                color: var(--color-info) !important;
                font-size: 13px !important;
                font-weight: 500;
            }
            
            /* 暂存状态样式 */
            .pending-row {
                background: linear-gradient(135deg, #fffbf0 0%, #fef7e0 100%);
                border-left: 3px solid #faad14;
            }
            
            .pending-badge {
                background: #faad14;
                color: white;
                padding: 2px 6px;
                border-radius: 8px;
                font-size: 10px;
                font-weight: 500;
                margin-left: 8px;
                display: inline-block;
            }
            
            .status-badge.status-pending {
                background: linear-gradient(135deg, #faad14 0%, #ffc53d 100%);
                color: white;
                border: 1px solid #d48806;
            }
            
            .btn-small.btn-warning {
                background: #faad14;
                color: white;
                border: 1px solid #d48806;
            }
            
            .btn-small.btn-warning:hover {
                background: #ffc53d;
                border-color: #faad14;
                transform: translateY(-1px);
            }
            
            /* 取消按钮使用红色背景 */
            .btn-small.btn-danger {
                background: #f56c6c;
                color: white;
                border: 1px solid #f15656;
            }
            
            .btn-small.btn-danger:hover {
                background: #f78989;
                border-color: #f56c6c;
                transform: translateY(-1px);
            }
        </style>
    `;

    document.head.insertAdjacentHTML('beforeend', styles);
    console.log('✅ 查看模式样式已添加');
}

// 当页面加载时自动添加样式
if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', addViewModeStyles);
} else {
    addViewModeStyles();
}

// ================================ IIFE 闭合 ================================


// 模块加载调试信息
console.log('🎉 [调试] IIFE执行完成！');
console.log('🎉 [调试] window.V3StrategyConfigManager 存在:', !!window.V3StrategyConfigManager);
console.log('🎉 [调试] 模块类型:', typeof window.V3StrategyConfigManager);

if (window.V3StrategyConfigManager) {
    console.log('🎉 [调试] 模块方法:', Object.keys(window.V3StrategyConfigManager));
    console.log('🎉 [调试] init方法类型:', typeof window.V3StrategyConfigManager.init);
} else {
    console.error('❌ [调试] V3StrategyConfigManager模块加载失败');
}
